Escape sequences are used in the programming languages C and C++, and
also in many more languages like Java and C#. An escape sequence is a sequence
of characters that does not represent itself when used inside a character or
string literal, but is translated into another character or a sequence of
characters that may be difficult or impossible to represent directly.
In C, all escape sequences consist of two or more characters, the first of
which is the backslash, \; the remaining characters determine the interpretation
of the escape sequence. For example, \n is an escape sequence that denotes a
newline character. The remainder of this article focuses on C; other programming
languages are likely to have different syntax and semantics.
Motivation Suppose we want to print out Hello, on
one line, followed by world! on the next line. One could attempt to represent the
string to be printed as a single literal as follows:
This is not valid in C, since a string literal may not span multiple logical
source lines. This can be worked around by printing the newline character using
its numerical value, This instructs the program to print
Hello,, followed by the character whose numerical value is 0x0a, followed by
world!. While this will indeed work when the machine uses the ASCII encoding, it
will not work on systems that use other encodings, that have a different
numerical value for the newline character. It is also not a good
solution because it still does not allow us to represent a newline character
inside a literal, and instead takes advantage of the semantics of printf. In
order to solve these problems and ensure maximum portability between systems, C
interprets \n inside a character or string literal as a newline character,
whatever that may be on the target system:
In this code, the escape sequence \n does not stand for a backslash followed
by the letter n, because the backslash causes an "escape" from the normal way
characters are interpreted by the compiler. After seeing the backslash,
the compiler expects another character to complete the escape sequence, and
then translates the escape sequence into the character it is intended to
represent. Thus, "Hello,\nworld!" represents a string with an embedded
newline, regardless of whether it is used inside printf or anywhere else.
This raises the issue of how to represent an actual backslash inside a
literal. This is done by using the escape sequence \\, as seen in the next
section. Table of escape sequences
The following escape sequences are defined in standard C. This table also
shows the values they map to in ASCII. However, these escape sequences can be
used on any system with a C compiler, and may map to different values if the
system does not use a character encoding based on ASCII.
= Notes = Each escape sequence in the above table
maps to a single character, including \n. This is despite the fact that the
platform may use more than one character to denote a newline, such as the
MS-DOS/Windows CR-LF sequence, 0x0d 0x0a. The translation from 0x0a to 0x0d
0x0a on MS-DOS and Windows occurs when the character or string is written out
to a file or to the console, but \n only creates a single character within the
memory of the program itself. A hex escape sequence must have at least
one hex digit following \x, with no upper bound; it continues for as many
hex digits as there are. Thus, for example, \xABCDEFG denotes the character
with the numerical value ABCDEF16, followed by the letter G, which is not a
hex digit. However, if the resulting integer value is too large to fit in a
single character, the actual numerical value assigned is
implementation-defined. Most platforms have 8-bit 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 string
literal: An octal escape sequence consists of \
followed by one, two, or three octal digits. The octal escape sequence ends
when it either contains three octal digits already, or the next character is
not an octal digit. For example, \11 is a single octal escape sequence denoting
a character with numerical value 9, rather than the escape sequence \1
followed by the digit 1. However, \1111 is the octal escape sequence \111
followed by the digit 1. In order to denote the character with numerical
value 1, followed by the digit 1, one could use "\1""1", since C automatically
concatenates adjacent string literals. Note that some three-digit octal escape
sequences may be too large to fit in a single character; this results in an
implementation-defined value for the character actually produced. The escape
sequence \0 is a commonly used octal escape sequence, which denotes the null
character, with value zero. = Non-standard escape sequences =
A sequence such as \z is not a valid escape sequence according to the C
standard as it is not found in the table above. The C standard requires such
"invalid" escape sequences to be diagnosed. Notwithstanding this fact,
some compilers may define additional escape sequences, with
implementation-defined semantics. An example is the \e escape sequence, which
has 1B as the hexadecimal value in ASCII, represents the escape character,
and is supported in GCC, clang and tcc. = Universal character names =
Since the C99 standard, C has also supported escape sequences that denote
Unicode code points in string literals. Such escape sequences are called
universal character names, and have the form \uxxxx or \Uxxxxxxxx, where x
stands for a hex digit. Unlike the other escape sequences considered, a universal
character name may expand into more than one code unit.
The sequence \uxxxx denotes the code point xxxx, interpreted as a hexadecimal
number. The sequence \Uxxxxxxxx denotes the code point xxxxxxxx, interpreted as
a hexadecimal number. The code point is converted into a sequence of code units
in the encoding of the destination type on the target system. For example,
consider The string s1 will contain a single char
object whose numerical value, the actual value stored in memory, is in fact 0xC0.
However, the string s2 will contain the character "À", U+00C0 LATIN CAPITAL
LETTER A WITH GRAVE. It may contain more than one char; their number and values
depend on the encoding used by the system. On a system that uses the UTF-8
encoding, the string s2 will contain two char objects, 0xC3 0x80. The string s3
contains a single wchar_t object, again with numerical value 0xC0. The string s4
contains the character "À" encoded into wchar_t objects. If the UTF-16 encoding
is used, then s4 will also contain only a single wchar_t, 16 bits long, with
numerical value 0x00C0. A universal character name such as \U0001F603 may be
represented by a single wchar_t object if the UTF-32 encoding is used, or two
if UTF-16 is used. Importantly, the universal character
name \u00C0 always denotes the character "À", regardless of what kind of string
literal it is used in, or the encoding in use. Again, \U0001F603 always denotes
the character at code point 1F60316, regardless of context. On the other
hand, 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 "physical" characters, universal character names
represent code points, which may be thought of as "logical" characters.
References ISO/IEC 9899:1999, Programming languages
— C Kernighan, Brian W.; Ritchie, Dennis M..
The C Programming Language. Prentice Hall. ISBN 9780133086218.
Lafore, Robert. Object-Oriented Programming in Turbo C++. Galgotia
Publications. ISBN 9788185623221. See also
Escape sequence