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

  • Amandeep

    I never use "return 0" at the end of my main() and my programs work fine. So why is it used in every program here? Are there some special cases where not using "return 0" will lead to errors or is it just a standard practice?

    • Alex

      In C++, the main function must return a value to the operating system. We typically return 0 to indicate that "the program ran okay".

      Some compilers (such as Visual Studio) will let you omit the return value in main (they'll return 0 for you), but best practice is not to rely on this.

  • "cout outputs the char variable as an ASCII character instead of a number", Alex please tell me how cin takes input from a user. As an ASCII code or simple keyboard character. This program is a bit tricky for me:

    Suppose someone entered 9 as input for variable ch. When cout is printing result, 9 remains 9 (before static_cast) and cout does not interpret it as  ASCII code. When cin is removed from the program and ch is given a value like this:

    It produces "b has ASCII code 98". Sorry, if I am so stupid, but why results are different in above cases. Does cin takes input in this form:

    One more thing. When I assign 98 with single quotes to a char variable (char ch(’98’)), my compiler warns me that the variable is given a multi-character constant. On running the program, cout only prints the last digit (e.g. 8 for 98). Why so?

    • Alex

      In your top example, ch is of type char, so when the user inputs '9', "cin >> ch" will treat the user input as '9' (the character) and not 9 (the integer).

      If you had defined ch as an int, "cin >> ch" would have treated the input as 9 (the integer) instead. If ch was defined as a string, "cin >> ch" would have treated the input as "9" (the string) instead.

      So, in other words, cin looks at the data type of the variable being input into, and infers what the most appropriate value should be from that.

      Remember that chars can only hold a single char. '98' is two chars, which is why you are getting a warning. Visual Studio at least seems to truncate this to the last character. I'm not sure why they made that decision instead of treating it as an error.

  • The Razer

    is string a char type ?
    for example :

    can you explane a little about this variable type ?

    • Alex

      string isn't a char type. string is a special type of object called a class, and explaining classes at this point would be complicated.

      You can think of a string as a sequential collection of chars (each character in "qwerty" is a char).

  • Robin

    Where you say
    the <new_type> gets parsed as html and is not showing
    using static_cast&lt;new_type&gt;(expression) would fix this

  • AK

    You have suggested to use std::endl when you need to ensure your output is output immediately and use ‘n’ in other cases.

    But I see the both are line buffered. i.e., both output the full output buffer when used.

    • Alex

      When printing to a console, this is generally true. However, when writing to disk, 'n' may not cause any buffered input to be written to disk immediately, whereas std::end will.

  • Todd


    "When using cout to print a char, cout outputs the char variable as an ASCII characters (character) instead of a number"

    "The rest of the user input is left in the input buffer that cin uses, and can be access (accessed) with subsequent calls to cin."

  • Aditya

    Even if the value of 'op' the user enters is not ;+; or '-', i do not get the invalid operator output. It assumes op=- and caries out subtraction
    I understand that i could use switch case to get the desired result, I am curious as to why this fails.


  • Alex

    I want to tell you how much I appreciate this tutorial - and ask one question/clarification.

    I am just learning C++ so I can create a stand-alone application for my daughter.  I have previously coded in php, bash, java and html, but this is my first crack at a compiled program.  I (as usual) just dove in and started trying some things (usually worked best for me) but found numerous topics in C++ confusing so started looking for more help.

    I found this site and it has been wonderful!  It lets me learn by trying - something I like to do - AND it explains the why of things - something I need to really learn something.  

    Thank you.  

    I do have one question.

    In the example above where you have:

    is that supposed to be:

    If so, I understand what you are saying.

    If not, I am not sure what you are getting at.

    Thanks again for making this interesting, informative and educational.


  • Twisted Code

    Why does the questionmark character have an escape sequence? Does "?" do something special in a string or character-typed object? If so, what chapter can I jump to to find out more?

  • Dan Downs

    Your introduction to ASCII took me back decades, when ASCII was new and slowly replacing Baudot code used by teletypes. I was an AF communications tech, we still had tube equipment while integrated circuits were coming out and the biggest fastest communications terminal we had was the IBM 360 to do a job done by a single chip today. Some of those characters below char(32) were vital to digital transmission, which consisted of 80 character blocks transmitted synchronously at speeds up to 1200 baud (about 1.2 kB/s) using very expensive modems. SOH, ETX, EOM, ACK NAK and SYN for example were critical at the time. Of course they are obsolete but they certainly played an important roll in their day.  Thanks for the memories.  The tutorial is very good, thank you.

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