View source for Escape sequences in C

{{Short description|Special character sequences in the C programming language}}
{{more footnotes |date=September 2013}}
{{Use American English|date=March 2019}}
{{Use dmy dates|date=May 2019|cs1-dates=y}}
In the  [[C (programming language)|C programming language]], an [[escape sequence]] is specially [[delimited]] text in a [[Character (computing)|character]] or [[String (computer science)|string]] [[Literal (computer programming)|literal]] that represents one or more other characters to the [[compiler]]. It allows a [[programmer]] to specify characters that are otherwise difficult or impossible to specify in a literal.

An escape sequence starts with a backslash ({{mono|\}}) called the [[escape character]] and subsequent characters define the meaning of the escape sequence. For example, {{mono|\n}} denotes a [[newline]] character.

The same or similar escape sequences are used in other, related languages such [[C++]], [[C Sharp (programming language)|C#]], [[Java (programming language)|Java]] and [[PHP]].

== Value ==

To demonstrate the value of the escape sequence feature, to output the text {{mono|Foo}} on one line and {{mono|Bar}} on the next line, the code must output a newline between the two words.

The following code achieves the goal via [[printf|text formatting]] and a hard-coded [[ASCII]] character value for newline (0x0A). This behaves as desired with the words on sequential lines, but an escape sequence has advantages.

<syntaxhighlight lang="c">
#include <stdio.h>
int main() {
    printf("Foo%cBar", 0x0A);
    return 0;
}
</syntaxhighlight>

The {{mono|\n}} escape sequence allows for shorter code by specifying the newline in the string literal, and for faster [[Runtime (program lifecycle phase)|runtime]] by eliminating the text formatting operation. Also, the compiler can map the escape sequence to a [[character encoding]] system other than ASCII and thus make the code more [[Software portability|portable]].

<syntaxhighlight lang="c">
#include <stdio.h>
int main() {
    printf("Foo\nBar");
    return 0;
}
</syntaxhighlight>

== How it works ==

An escape sequence changes how the compiler interprets character data in a literal. For example, {{mono|\n}} does not represent a backslash followed by the letter {{mono|n}}. The backslash ''escapes'' the compiler's normal, literal way of interpreting character data. After a backslash, the compiler expects subsequent characters to complete one of the defined escape sequences, and then translates the escape sequence into the characters it represents.

This syntax does require special handling to encode a backslash character {{endash}} since it is a [[metacharacter]] that changes literal interpretation behavior; not the literal backslash character. The issue is solved by using two backslashes ({{mono|\\}}) to mean one.

== Escape sequences ==

The following table includes escape sequences defined in standard C as well as some non-standard sequences.
The C standard requires an escape sequence that does not match a defined sequence to be diagnosed {{endash}} i.e., the compiler must print an error message. Regardless, some compilers define additional escape sequences. 

The table shows the ASCII value a sequence maps to, however, it may map to different values based on encoding.

{| class="wikitable sortable"
|-
! Escape sequence !! Hex value in ASCII !! Character represented
|-
| {{mono|\a}} || 07 || [[Bell character|Alert (Beep, Bell)]] (added in C89)<ref name="Rationale_2003_C"/>
|-
| {{mono|\b}} || 08 || [[Backspace]]
|-
| {{mono|\e}}{{Ref|Note1|note 1}} || 1B || [[Escape character]]
|-
| {{mono|\f}} || 0C || [[Formfeed]] [[Page Break]]
|-
| {{mono|\n}} || 0A || [[Newline]] (Line Feed); see below
|-
| {{mono|\r}} || 0D || [[Carriage Return]]
|-
| {{mono|\t}} || 09 || [[Horizontal Tab]]
|-
| {{mono|\v}} || 0B || [[Vertical Tab]]
|-
| {{mono|\\}} || 5C || [[Backslash]]
|-
| {{mono|\'}} || 27 || [[Apostrophe]] or single quotation mark
|-
| {{mono|\"}} || 22 || Double [[quotation mark]]
|-
| {{mono|\?}} || 3F || [[Question mark]] (used to avoid [[Digraphs and trigraphs (programming)#C|trigraphs]])
|-
| {{mono|\''nnn''}}{{Ref|Note2|note 2}} || ''nnn'' (octal) || The byte whose numerical value is given by ''nnn'' interpreted as an [[octal]] number
|-
| {{mono|\x''hh…''}} || ''hh…'' || The byte whose numerical value is given by ''hh…'' interpreted as a [[hexadecimal]] number
|-
| {{mono|\u''hhhh''}}{{Ref|Note3|note 3}} || ''non-ASCII'' || [[Unicode]] [[code point]] below 10000 hexadecimal (added in C99){{R|Rationale_2003_C|p=26}}
|-
| {{mono|\U''hhhhhhhh''}}{{Ref|Note4|note 4}} || ''non-ASCII'' || Unicode code point where ''h'' is a hexadecimal digit
|}

=== Escape ===

{{Note|Note1}}
The non-standard sequence {{Mono|\e}} represents the [[escape character]] in [[GNU Compiler Collection|GCC]],<ref name="GCC"/> [[clang]] and [[Tiny C Compiler|tcc]]. It was not added to the C standard because it has no meaningful equivalent in some [[character set]]s (such as [[EBCDIC]]).<ref name="Rationale_2003_C"/>

=== Newline ===

Sequence {{mono|\n}} maps to one byte, despite the fact that the [[Newline#Issues_with_different_newline_formats|platform may use]] more than one byte to denote a newline, such as the [[DOS]]/[[Windows]] [[CRLF]] sequence, {{mono|0x0D 0x0A}}. The translation from {{mono|0x0A}} to {{mono|0x0D 0x0A}} on DOS and Windows occurs when the byte is written out to a file or to the console, and the inverse translation is done when text files are read.

=== Hex ===

A [[Hexadecimal|hex]] escape sequence must have at least one hex digit following {{mono|\x}}, with no upper bound; it continues for as many hex digits as there are. Thus, for example, {{mono|\xABCDEFG}} denotes the byte with the numerical value ABCDEF<sub>16</sub>, followed by the letter {{mono|G}}, which is not a hex digit. However, if the resulting integer value is too large to fit in a single byte, the actual numerical value assigned is implementation-defined. Most platforms have 8-bit {{mono|char}} types, which limits a useful hex escape sequence to two hex digits. However, hex escape sequences longer than two hex digits might be useful inside a wide character or wide string literal (prefixed with L):
<syntaxhighlight lang="c">
// single char with value 0x12 (18 decimal)
char s1[] = "\x12";
// single char with implementation-defined value, unless char is long enough
char s1[] = "\x1234";
// single wchar_t with value 0x1234, provided wchar_t is long enough (16 bits suffices)
wchar_t s2[] = L"\x1234";
</syntaxhighlight>

=== Octal ===

{{Note|Note2}}
An [[octal]] escape sequence consists of a backslash followed by one to three octal digits. The octal escape sequence ends when it either contains three octal digits, or the next character is not an octal digit. For example, {{mono|\11}} is an octal escape sequence denoting a byte with decimal value 9 (11 in octal). However, {{mono|\1111}} is the octal escape sequence {{mono|\111}} followed by the digit {{mono|1}}. In order to denote the byte with numerical value 1, followed by the digit {{mono|1}}, one could use {{mono|"\1""1"}}, since C concatenates adjacent string literals.

Some three-digit octal escape sequences are too large to fit in a single byte. This results in an implementation-defined value for the resulting byte.

The escape sequence {{mono|\0}} is a commonly used octal escape sequence, which denotes the null character, with value zero in ASCII and most encoding systems.

=== Universal character names ===

{{Note|Note3}}
{{Note|Note4}}
Since the [[C99]] standard, C supports escape sequences that denote [[Unicode]] [[code point]]s, called ''universal character names''. They have the form {{mono|\u''hhhh''}} or {{mono|\U''hhhhhhhh''}}, where {{mono|''h''}} stands for a hex digit. Unlike other escape sequences, a universal character name may expand into more than one code unit.

The sequence {{mono|\u''hhhh''}} denotes the code point {{mono|''hhhh''}}, interpreted as a hexadecimal number. The sequence {{mono|\U''hhhhhhhh''}} denotes the code point {{mono|''hhhhhhhh''}}, interpreted as a hexadecimal number. Code points located at U+10000 or higher must be denoted with the {{mono|\U}} syntax, whereas lower code points may use {{mono|\u}} or {{mono|\U}}. The code point is converted into a sequence of [[code unit]]s in the encoding of the destination type on the target system. For example, where the encoding is [[UTF-8]], and [[UTF-16]] for {{mono|wchar_t}}:
<syntaxhighlight lang="c">
// A single byte with the value 0xC0; not valid UTF-8
char s1[] = "\xC0";
// Two bytes with values 0xC3, 0x80; the UTF-8 encoding of U+00C0
char s2[] = "\u00C0";
// A single wchar_t with the value 0x00C0
wchar_t s3[] = L"\xC0";
// A single wchar_t with the value 0x00C0
wchar_t s4[] = L"\u00C0";
</syntaxhighlight>

A value greater than {{mono|\U0000FFFF}} may be represented by a single {{mono|wchar_t}} if the [[UTF-32]] encoding is used, or two if UTF-16 is used.

Importantly, the universal character name {{mono|\u00C0}} always denotes the character "À", regardless of what kind of string literal it is used in, or the encoding in use. The octal and hex escape sequences always denote certain sequences of numerical values, regardless of encoding. Therefore, universal character names are complementary to octal and hex escape sequences; while octal and hex escape sequences represent code units, universal character names represent code points, which may be thought of as "logical" characters.

== Alternatives ==

Some languages provide different mechanisms for coding behavior that the escape sequence provide. For example, the following [[Pascal (programming language)|Pascal]] code writes the two words on sequential lines:

<syntaxhighlight lang="pascal">
writeln('Foo');
write('Bar');
</syntaxhighlight>

{{mono|writeln}} outputs a newline after the parameter text, while {{mono|write}} does not.

== See also ==
* [[Escape sequence]]
* [[Digraph (computing)|Digraph]]

== References ==
{{reflist|refs=
<ref name="Rationale_2003_C">{{cite web |title=Rationale for International Standard - Programming Languages - C |version=5.10 |date=April 2003 |url=http://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf |access-date=2010-10-17 |url-status=live |archive-url=https://web.archive.org/web/20160606072228/http://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf |archive-date=2016-06-06}}</ref>
<ref name="GCC">{{cite book |title=GCC 4.8.2 Manual |chapter=6.35 The Character <ESC> in Constants |chapter-url=https://gcc.gnu.org/onlinedocs/gcc-4.8.2/gcc/Character-Escapes.html#Character-Escapes |access-date=2014-03-08 |url-status=live |archive-url=https://archive.today/20190512120819/https://gcc.gnu.org/onlinedocs/gcc-4.8.2/gcc/Character-Escapes.html%23Character-Escapes |archive-date=2019-05-12}}</ref>
}}

== Further reading ==
* ISO/IEC 9899:1999, ''Programming languages — C''
* {{cite book |author-last1=Kernighan |author-link1=Brian Kernighan |author-first1=Brian W. |author-last2=Ritchie |author-link2=Dennis Ritchie |author-first2=Dennis M. |title=The C Programming Language |title-link=The C Programming Language |publisher=[[Prentice Hall]] |date=2003 |orig-year=1988 |edition=2 |isbn=978-0-13308621-8}}
* {{cite book |author-last=Lafore |author-first=Robert |author-link=Robert Lafore |date=2001 |title=Object-Oriented Programming in Turbo C++ |publisher=Galgotia Publications |isbn=978-8-18562322-1 |edition=1}}


[[Category:C (programming language)]]
[[Category:Control characters]]