Escape sequences

Escape sequences are used to define certain special characters within string literals.

The following escape sequences are available:

Escape sequence	Description	Representation
`\'`	single quote	byte `0x27`
`\"`	double quote	byte `0x22`
`\?`	question mark	byte `0x3f`
`\\`	backslash	byte `0x5c`
`\0`	null character	byte `0x00`
`\a`	audible bell	byte `0x07`
`\b`	backspace	byte `0x08`
`\f`	form feed - new page	byte `0x0c`
`\n`	line feed - new line	byte `0x0a`
`\r`	carriage return	byte `0x0d`
`\t`	horizontal tab	byte `0x09`
`\v`	vertical tab	byte `0x0b`
`\nnn`	arbitrary octal value	byte `nnn`
`\xnn`	arbitrary hexadecimal value	byte `nn`
`\unnnn`	arbitrary Unicode value. May result in several characters.	code point `U+nnnn`
`\Unnnnnnnn`	arbitrary Unicode value. May result in several characters.	code point `U+nnnnnnnn`

[edit] Notes

The new-line character \n has special meaning when used in text mode I/O, it is converted to the OS-specific newline byte or byte sequence.

Octal escape sequences have a limit of three octal digits, but terminate at the first character that is not a valid octal digit if encountered sooner.

Hexadecimal escape sequences have no length limit and terminate at the first character that is not a valid hexadecimal digit. If the value represented by a single hexadecimal escape sequence does not fit the range of values represented by the character type used in this string literal (char, char16_t, char32_t, or wchar_t), the result is unspecified.

A universal character name in a narrow string literal may map to more than one char due to multibyte encoding.

The question mark escape sequence \? is used to prevent trigraphs from being interpreted inside string literals: a string such as "??/" is compiled as "\", but if the second question mark is escaped, as in "?\?/", it becomes "??/"

[edit] Example

Run this code

#include <iostream>
 
int main()
{
    std::printf("This\nis\na\ntest\n\nShe said, \"How are you?\"\n");
}

Output:

This
is
a
test
 
She said, "How are you?"

[edit] See also

ASCII chart

Language
Standard library headers
Concepts
Utilities library
Strings library
Containers library
Algorithms library
Iterators library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)

General
value categories (lvalue, rvalue, xvalue)
order of evaluation (sequence points)
constant expressions
unevaluated expressions
primary expressions
lambda-expression(C++11)
Literals
integer literals
floating-point literals
boolean literals
character literals including escape sequences
string literals
null pointer literal(C++11)
user-defined literal(C++11)
Operators
Assignment operators: `a=b`, `a+=b`, `a-=b`, `a*=b`, `a/=b`, `a%=b`, `a&=b`, `a\|=b`, `a^=b`, `a<<=b`, `a>>=`
Increment and decrement: `++a`, `--a`, `a++`, `a--`
Arithmetic operators: `+a`, `-a`, `a+b`, `a-b`, `a*b`, `a/b`, `a%b`, `~a`, `a&b`, `a\|b`, `a^b`, `a<<b`, `a>>b`
Logical operators: `a\|\|b`}, `a&&b`, `!a`
Comparison operators: `a==b`, `a!=b`, `a<b`, `a>b`, `a<=b`, `a>=b`
Member access operators: `a[b]`, `a`, `&a`, `a->b`, `a.b`, `a->b`, `a.*b`
Other operators: `a(...)`, `a,b`, `(T)a`, `a?b:c`
Alternative representations of operators
Precedence and associativity
new-expression
delete-expression
throw-expression
alignof
sizeof
sizeof...(C++11)
typeid
noexcept(C++11)
Operator overloading
Conversions
Implicit conversions
const_cast
static_cast
reinterpret_cast
dynamic_cast
Explicit conversions `(T)a`, `T(a)`
User-defined conversion