4.11 — Chars

To this point, the fundamental data types we’ve looked at have been used to hold numbers (integers and floating point) or true/false values (booleans). But what if we want to store letters?

The char data type was designed to hold a character. A character can be a single letter, number, symbol, or whitespace.

The char data type is an integral type, meaning the underlying value is stored as an integer. Similar to how a Boolean value 0 is interpreted as false and non-zero is interpreted as true, the integer stored by a char variable are intepreted as an ASCII character.

ASCII stands for American Standard Code for Information Interchange, and it defines a particular way to represent English characters (plus a few other symbols) as numbers between 0 and 127 (called an ASCII code or code point). For example, ASCII code 97 is interpreted as the character ‘a’.

Character literals are always placed between single quotes (e.g. ‘g’, ‘1’, ‘ ‘).

Here’s a full table of ASCII characters:

Code Symbol Code Symbol Code Symbol Code Symbol
0 NUL (null) 32 (space) 64 @ 96 `
1 SOH (start of header) 33 ! 65 A 97 a
2 STX (start of text) 34 66 B 98 b
3 ETX (end of text) 35 # 67 C 99 c
4 EOT (end of transmission) 36 $ 68 D 100 d
5 ENQ (enquiry) 37 % 69 E 101 e
6 ACK (acknowledge) 38 & 70 F 102 f
7 BEL (bell) 39 71 G 103 g
8 BS (backspace) 40 ( 72 H 104 h
9 HT (horizontal tab) 41 ) 73 I 105 i
10 LF (line feed/new line) 42 * 74 J 106 j
11 VT (vertical tab) 43 + 75 K 107 k
12 FF (form feed / new page) 44 , 76 L 108 l
13 CR (carriage return) 45 - 77 M 109 m
14 SO (shift out) 46 . 78 N 110 n
15 SI (shift in) 47 / 79 O 111 o
16 DLE (data link escape) 48 0 80 P 112 p
17 DC1 (data control 1) 49 1 81 Q 113 q
18 DC2 (data control 2) 50 2 82 R 114 r
19 DC3 (data control 3) 51 3 83 S 115 s
20 DC4 (data control 4) 52 4 84 T 116 t
21 NAK (negative acknowledge) 53 5 85 U 117 u
22 SYN (synchronous idle) 54 6 86 V 118 v
23 ETB (end of transmission block) 55 7 87 W 119 w
24 CAN (cancel) 56 8 88 X 120 x
25 EM (end of medium) 57 9 89 Y 121 y
26 SUB (substitute) 58 : 90 Z 122 z
27 ESC (escape) 59 ; 91 [ 123 {
28 FS (file separator) 60 < 92 \ 124 |
29 GS (group separator) 61 = 93 ] 125 }
30 RS (record separator) 62 > 94 ^ 126 ~
31 US (unit separator) 63 ? 95 _ 127 DEL (delete)

Codes 0-31 are called the unprintable chars, and they’re mostly used to do formatting and control printers. Most of these are obsolete now.

Codes 32-127 are called the printable characters, and they represent the letters, number characters, and punctuation that most computers use to display basic English text.

Initializing chars

You can initialize char variables using character literals:

You can initialize chars with integers as well, but this should be avoided if possible


Be careful not to mix up character numbers with integer numbers. The following two initializations are not the same:

Character numbers are intended to be used when we want to represent numbers as text, rather than as numbers to apply mathematical operations to.

Printing chars

When using std::cout to print a char, std::cout outputs the char variable as an ASCII character:

This produces the result:


We can also output char literals directly:

This produces the result:


A reminder

The fixed width integer int8_t is usually treated the same as a signed char in C++, so it will generally print as a char instead of an integer.

Printing chars as integers via type casting

If we want to output a char as a number instead of a character, we have to tell std::cout to print the char as if it were an integer. One (poor) way to do this is by assigning the char to an integer, and printing the integer:

However, this is clunky. A better way is to use a type cast. A type cast creates a value of one type from a value of another type. To convert between fundamental data types (for example, from a char to an int, or vice versa), we use a type cast called a static cast.

The syntax for the static cast looks a little funny:


static_cast takes the value from an expression as input, and converts it into whatever fundamental type new_type represents (e.g. int, bool, char, double).

Key insight

Whenever you see C++ syntax (excluding the preprocessor) that makes use of angled brackets, the thing between the angled brackets will most likely be a type. This is typically how C++ deals with concepts that need a parameterizable type.

Here’s using a static cast to create an integer value from our char value:

This results in:


It’s important to note that the parameter to static_cast evaluates as an expression. When we pass in a variable, that variable is evaluated to produce its value, which is then converted to the new type. The variable is not affected by casting its value to a new type. In the above case, variable ch is still a char, and still holds the same value.

Also note that static casting doesn’t do any range checking, so if you cast a large integer into a char, you’ll overflow your char.

We’ll talk more about static casts and the different types of casts in a future lesson (6.15 -- Explicit type conversion (casting)).

Inputting chars

The following program asks the user to input a character, then prints out both the character and its ASCII code:

Here’s the output from one run:

Input a keyboard character: q
q has ASCII code 113

Note that std::cin will let you enter multiple characters. However, variable ch can only hold 1 character. Consequently, only the first input character is extracted into variable ch. The rest of the user input is left in the input buffer that std::cin uses, and can be extracted with subsequent calls to std::cin.

You can see this behavior in the following example:

Input a keyboard character: abcd
a has ASCII code 97
b has ASCII code 98

Char size, range, and default sign

Char is defined by C++ to always be 1 byte in size. By default, a char may be signed or unsigned (though it’s usually signed). If you’re using chars to hold ASCII characters, you don’t need to specify a sign (since both signed and unsigned chars can hold values between 0 and 127).

If you’re using a char to hold small integers (something you should not do unless you’re explicitly optimizing for space), you should always specify whether it is signed or unsigned. A signed char can hold a number between -128 and 127. An unsigned char can hold a number between 0 and 255.

Escape sequences

There are some characters in C++ that have special meaning. These characters are called escape sequences. An escape sequence starts with a ‘\’ (backslash) character, and then a following letter or number.

You’ve already seen the most common escape sequence: ‘\n’, which can be used to embed a newline in a string of text:

This outputs:

First line
Second line

Another commonly used escape sequence is ‘\t’, which embeds a horizontal tab:

Which outputs:

First part        Second part

Three other notable escape sequences are:
\’ prints a single quote
\” prints a double quote
\\ prints a backslash

Here’s a table of all of the escape sequences:

Name Symbol Meaning
Alert \a Makes an alert, such as a beep
Backspace \b Moves the cursor back one space
Formfeed \f Moves the cursor to next logical page
Newline \n Moves cursor to next line
Carriage return \r Moves cursor to beginning of line
Horizontal tab \t Prints a horizontal tab
Vertical tab \v Prints a vertical tab
Single quote \’ Prints a single quote
Double quote \” Prints a double quote
Backslash \\ Prints a backslash.
Question mark \? Prints a question mark.
No longer relevant. You can use question marks unescaped.
Octal number \(number) Translates into char represented by octal

Hex number \x(number) Translates into char represented by hex number

Here are some examples:


"This is quoted text"
This string contains a single backslash \
6F in hex is char 'o'

Newline (\n) vs. std::endl

We cover this topic in lesson 1.5 -- Introduction to iostream: cout, cin, and endl.

What’s the difference between putting symbols in single and double quotes?

Stand-alone chars are always put in single quotes (e.g. ‘a’, ‘+’, ‘5’). A char can only represent one symbol (e.g. the letter a, the plus symbol, the number 5). Something like this is illegal:

Text put between double quotes (e.g. “Hello, world!”) is called a string. A string is a collection of sequential characters (and thus, a string can hold multiple symbols).

For now, you’re welcome to use string literals in your code:

We’ll discuss strings in the next lesson (4.12 -- An introduction to std::string).


Always put stand-alone chars in single quotes (e.g. ‘t’ or ‘\n’, not “t” or “\n”). This helps the compiler optimize more effectively.

What about the other char types, wchar_t, char16_t, and char32_t?

wchar_t should be avoided in almost all cases (except when interfacing with the Windows API). Its size is implementation defined, and is not reliable. It has largely been deprecated.

As an aside...

The term “deprecated” means “still supported, but no longer recommended for use, because it has been replaced by something better or is no longer considered safe”.

Much like ASCII maps the integers 0-127 to American English characters, other character encoding standards exist to map integers (of varying sizes) to characters in other languages. The most well-known mapping outside of ASCII is the Unicode standard, which maps over 110,000 integers to characters in many different languages. Because Unicode contains so many code points, a single Unicode code point needs 32-bits to represent a character (called UTF-32). However, Unicode characters can also be encoded using multiple 16-bit or 8-bit characters (called UTF-16 and UTF-8 respectively).

char16_t and char32_t were added to C++11 to provide explicit support for 16-bit and 32-bit Unicode characters. char8_t has been added in C++20.

You won’t need to use char8_t, char16_t, or char32_t unless you’re planning on making your program Unicode compatible. Unicode and localization are generally outside the scope of these tutorials, so we won’t cover it further.

In the meantime, you should only use ASCII characters when working with characters (and strings). Using characters from other character sets may cause your characters to display incorrectly.

4.12 -- An introduction to std::string
4.11 -- Compound statements and nested blocks

87 comments to 4.11 — Chars

  • I think there is typo in the sentence below(should be 'char' instead of 'chat'):

    "The following two initializations both initialize the chat with integer value 97:"

    Also, the syntax for static_cast could have been(just saying):

  • Jeremy

    You can also print a char as a number using "integral promotion". Basically a unary + or - operator to the left of the variable:

    #include <iostream>

    int main()
        char chLetter = 'a';

        std::cout << chLetter << std::endl;

        // the unary + operator gives the integer value of a char:
        std::cout << +chLetter << std::endl;

        // the unary - operation gives the negative integer value of a char:
        std::cout << -chLetter << std::endl;

        // integral promotions are "value preserving" and do not change the value of the variable:
        std::cout << chLetter << std::endl;

        return 0;

  • Hey

    Thanks for this tut, it's very useful for me.

    First; after title "Escape sequences" in line 2 you wrote \. should not that be ?

    Second; can you bring an example for (number)?

    • Alex

      Fixed and done. I used the hex escape code instead of the octal escape code because hex is more commonly used in programming than octal. I can't remember the last time I used octal.

  • werthkew

    Can anyone tell me why the following program prints "-128" to the screen for chValue2?


    char chValue1 = 'a';
    char chValue2 = 128;

    int main()
    using namespace std;
    cout << chValue1 << endl;
    cout << (int)chValue2 << endl;
    return 0;

    • Xanth

      A char variable is only one byte, which means it can only hold 256 values. If it's signed (most compilers automatically sign variables) that means it can only hold integers from -128 to 127. If you unsign the variable using the unsigned command it'll be able to hold integers from 0 to 255. I ran the program to test it and if you unsign your char variable it works like a charm as long as you don't assign it anything higher than 255.

    • Alex

      Your chars are apparently signed by default (which is common).

      128 is outside the range for signed chars, so you're overflowing your char and it's wrapping around to the next number, which is -128.

      When you cast -128 to an int (also signed by default), cout prints it as -128.

  • dice3000

    cout << "\a";

    best thing ever :D

  • XxKarmaxX

    If this function were to run properly, shouldn't it return an integer at the end?

    #include "iostream";

    int main()
    using namespace std;
    char chChar;
    cout <> chChar;
    cout << chChar << " has ASCII code " << (int)chChar << endl;

  • lan

    Please i need some help here.
    For example on these lines of code

    char = cchar;
    cin>> cchar;

    if i input 10 at cchar it stores 10 as a string or as an integer?

    i made the code below to make a test in order to get the
    answer on the question that is above

    char cchar;
    char cchar2 = 5;

    i input 5 and it gives me a sum of 58
    on both couts, this make me understand that it takes
    the input of cchar as string because as you said in the tutorial:
    char chValue = '5'; // assigns 53 (ASCII code for '5')
    but i cant understand why at the second cout it takes (int)cchar2 as 53 shouldnt it have the value of 5 because of the (int).
    Please an answer would be appreciated.

    • You answered your own question - it stores 53, because as you said, it stores the ASCII code. when you add the (int), nothing changes, because cchar2 already has an int in it (53), hence it still thinks of it as 53.

  • Jupi

    Do programmers have to memorize escape sequences and stuff? It would be helpful if there was a single page with all the reference tables in it.. I'll just bookmark 'em for now (;

  • Cdoimne

    How come on one of the codes above it says

    #include "iostream"; ?

    Shouldn't it be

    #include ?

    Just saying.

  • jsieckman

    In the following example above:

    char chValue = '5'; // assigns 53 (ASCII code for '5')
    char chValue2 = 5; // assigns 5

    Does the bottom statement assign 5 or does it assign the character associated with the ASCII code for 5 (i.e. a club symbol)?


    • Alex

      The top statement assigns the character '5' (integer 53), which is printed as '5'.
      The bottom statement assigns in the integer value 5, which is printed as a club symbol in the Windows console.

Leave a Reply

You can use these HTML tags

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code class="" title="" data-url=""> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong> <pre class="" title="" data-url=""> <span class="" title="" data-url="">