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 (8.5 -- Explicit type conversion (casting) and static_cast).

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.10 -- Introduction to if statements

279 comments to 4.11 — Chars

  • Waldo Lemmer

    Section "Printing chars as integers via type casting":

    You may want to add some spaces inside the braces for readability


    You can use

    to change the color, background, etc. of all following text. See

  • Luca Zieserl

    Hello, alex, i think for new programmers the representation of the ascii character in the table assigned to 0 might be a bit irretating, they might think that the code 0 represents a space " ", because you wrote (space).

  • Chayim

    For what purpose is escape tab \t used if plain empty space does the same?

    • Jorge Diaz

      Well, if you are going to print a table, for example, you may want the elements of the table to be aligned

      Try running this code

      Maybe you're thinking you could just add manually the spaces, but if you're printing numbers from variables, you won't always know how many digits the number has

      • Chayim

        I don’t get what you’re trying to say. But from executing your code I see that tab formats different than space. Sometimes it skips two spaces and it aligns the text to the left, and I don’t understand what exactly tab does.

  • askingboy

    // Note: The following cin doesn't ask the user for input, it grabs queued input!

    does that work in loops too ?

    or should we input a character evertime

  • Pscyan

    Edit: I just used

    This still works so what's the point of using () instead of {} which is what we've been practicing all these time...

  • yeokaiwei

    1. Error
    I used

    Totally forgot operator was a keyword.

  • kiwiz

    Does cout prints the copy of the variable? If so, is this why static_cast<int>(x) converts the copy into an int?

    • nascardriver

      The `static_cast` creates a new `int` and the call to `std::cout <<` creates a copy.
      Your compiler might optimize the creation of the `int` away and just create an `int` right away (Rather than creating a `char` and converting it).

      • kiwiz

        Ok thanks. For the 'std::cout<<' part, it creates a copy, that i do not have to care right, since it is inevitable and is computer architect stuff. Another question is 'static_cast' creates an int as it returns a copy of the type specified right?

        • nascardriver

          Somehow your value has to get to `std::cout <&lt`. The fastest way to get a `char` from one place to another is to copy it.
          For larger types we'll avoid the copy. More on that later.

          `static_cast` creates a new variable based on the variable you gave it. This isn't a copy, because `static_cast` might have to modify the value (eg. floating point to integer), it is creation of a new object.
          For fundamental types, specifically integral types such as `char` and `int`, `static_cast` might avoid creating a new object if the two types are compatible without conversion, eg. if your compiler can store the `char` in a 4 byte register, it is identical to an `int`. These are just optimizations. You can always think of the returned value as a new object.

  • Waldo Lemmer

    Hey, great tutorial as always!

    1. In the second paragraph:

    > The char data type is an integral type, meaning the underlying value is stored as an integer, and it’s guaranteed to be 1-byte in size.

    The last part sounds like it's part of the definition of "integral". I recommend putting it in a new sentence.

    2. An interesting observation:

    This program prints "12", moves the cursor to the start of the line and then overwrites "12" with "34". Neat.

  • Kartaca

    Hey there is one question about chars ;

    #include <iostream>

    int main()
    std::cout<<"Enter an number "<<std::endl ;
    char ch{};
    return 0;

    why this prints a character like, If I input 97 , it needs to print a but it prints 9 ? why

    • nascardriver

      `std::cin` and `std::cout` treat `char` as a character, not as a number. When you enter "97", `std::cin` extracts the '9', because that's all it can fit into a `char`.

  • ryan fritz

    Is there any Negative ASCII characters, if YES then where can we find it, if NO then, if we try to call it, will it throw an Error or "does Wrapping", if it does wrapping then how does it wrap, similiar to wrapping in unsigned integers or something else entirely.
    Thank Your for Your Hard Work.

    • nascardriver

      ascii is not a specific type. It's just a table or list that you use to look up what a value means. If you have a negative value and that value is not in the list, do whatever you want to do. Print a question mark, throw an error, it's up to you.

  • Siddharth Singh

    Why is x+=i legal but x=x+i illegal statement when x and I are of type char in java?

  • Keshav

    Will we have to remember all the ASCII codes? If yes then how.

  • sami (Unicode and ASCII)

    Does "char8_t" type for Unicode have different symbols or character sets compared to ASCII for "char" type? For example, if code point 111 represents the letter 'o' in ASCII , then code point 111 might represent any other symbol in Unicode, right?

  • sami (flush buffer)

    " 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."

    According to the situation above, is there any way to flush or clear buffer in order to make std::cin to read a fresh input not what which is already in the buffer?

  • sami

    '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.'

    Would you please give an example when we cast a large integer into a char? I was wondering how could it be possible? I mean the maximum value in ASCII code is 127, so if we suppose that we have 'int x =300;' and converted 'x' to a char variable, which character would be displayed on the output? and what is the point of such conversion?

    • nascardriver

      Assuming `char` is `signed`:
      Before C++20, the value after the conversion was implementation-defined. That is, the developers of your compiler defined what happens, but it's not standardized.
      Since C++20, the original value is modulated, similar to signed integer overflow, but it's well defined. So if you have 127 and add one, you'll wrap around to -128. For 300, you'll get 44 (Which is a comma ',').

  • btelfer

    As I understand, chars (32-127) correspond certain numbers to symbols or letters (correct me if I am wrong). I have a question though: What is the benefit of this correspondence?

    • nascardriver

      32-126 (inclusive) are printable characters. There are some invisible characters (For example line feeds) below that and there may be printable characters above it (Language-specific characters, eg. the french é).

      Your computer can only store numbers.

  • Hi, I've decided to go off and do some extracurricular activity. I am trying to make this program initiate an endless loop of finding the ASCII character and asking if you want to do it again. Here is my code:

    It currently finds the ASCII character for the first input, asks if you want to do it again, and finds the second ASCII character, but then it terminates. Everything else works as desired except for the fact that it only does the loop once. Thanks for any help in advance!

    • Note: I changed the abort() on line 34 to exit()

    • nascardriver

      Avoid `std::exit` and `std::abort` altogether. They cause abnormal termination without cleanup. Let `main` finish to cause normal and safe termination.
      Line 19-24: You never need an if-statement like that. It should be replaced with `return (choice == 1)`.

      To repeat code, you need a loop. We show loops in chapter L.
      You can use a loop in your program like so

      `asciiFind` will be called. Then `tryAgain` is called and if it returns `true`, `asciiFind` is called again. This is repeated until `tryAgain` returns `false`.

  • OneSystem

    Hello! I am one of your students!

    In the example, the comment states "// cout prints a character" when it should say "// cout prints b character" :

  • Raffaello

    hello, I don't understand the error message here, I am using code::block 17.12 on windows 10, here's the code:

    it throws me an error on line 13, and says "error: invalid conversion from 'char (*)()' to 'char' [-fpermissive]".
    I tried changing the type of both variables in both functions, and the type of the function itself to int, but it throws the same exact error, just with the different types of course, so what am I missing? I also had this kind of issue on other code I was doing exercises on, so I'd like to know if I missed something about conversions so far :)

    • nascardriver

      There's nothing wrong with your code. The error message looks like you're compiling an old version of the file where you forgot the `()` after `functionChar`. If that's not the case, your compiler might be too old. Does your code compile if you use copy initialization?

  • Dave


    I thought I would add octal to the example below but it doesn't seem to work. I realise that octal isn't used much any more but I also wondered why you have left this out.
    Is there another preprocessor directive required, I wonder.

    • Dave

      This is my output is below but the octal output appears blank as the symbol is a square with tiny 0013 inside of it, which this web page seems to remove it. However, after playing around with different values, I partly understand what is going on here as the results are behaving as ascii codes, some of them behaving like control codes, such as escape, tab and backspace.

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

      Process returned 0 (0x0)   execution time : 0.003 s
      Press ENTER to continue.

    • nascardriver

      You answered your own question pretty much. Only some characters of the ascii-alphabet are printable, the rest historically performed other actions (eg. returning the carriage on a typewriter or ringing a bell). The little 13 you see means that the character is not printable, but has hex value 0x13.

  • Chayim

    "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."

    What has "int8_t" to do with "char" that it prints as "char"? It’s "int8_t" not "char8_t type.

    • nascardriver

      Every type in C++ is made up of fundamental types (char, int, float, etc.). Remember that `char` is an integer type. It just looks different when you print it. To get an 8 bit integer, implementations use `char`, because it's 8 bits wide.

Leave a Comment

Put all code inside code tags: [code]your code here[/code]