{"id":48,"date":"2007-06-09T19:07:05","date_gmt":"2007-06-10T03:07:05","guid":{"rendered":"http:\/\/www.learncpp.com\/?p=48"},"modified":"2025-03-19T09:53:22","modified_gmt":"2025-03-19T16:53:22","slug":"chars","status":"publish","type":"post","link":"https:\/\/www.learncpp.com\/cpp-tutorial\/chars\/","title":{"rendered":"4.11 — Chars"},"content":{"rendered":"

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

#include <iostream>\r\n\r\nint main()\r\n{\r\n    std::cout << \"Would you like a burrito? (y\/n)\";\r\n\r\n    \/\/ We want the user to enter a 'y' or 'n' character\r\n    \/\/ How do we do this?\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
The char<\/strong> data type was designed to hold a single character<\/code>.  A character<\/strong> can be a single letter, number, symbol, or whitespace.<\/p>\n
The char data type is an integral type, meaning the underlying value is stored as an integer.  Similar to how a Boolean value 0<\/code> is interpreted as false<\/code> and non-zero is interpreted as true<\/code>, the integer stored by a char<\/code> variable are intepreted as an ASCII character<\/code>.<\/p>\n
ASCII<\/strong> 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<\/strong> or code point<\/strong>).  For example, ASCII code 97 is interpreted as the character ‘a’.<\/p>\n
Character literals are always placed between single quotes (e.g. ‘g’, ‘1’, ‘ ‘).<\/p>\n
Here\u2019s a full table of ASCII characters:<\/p>\n
 <\/p>\n
<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Code<\/th>\nSymbol<\/th>\nCode<\/th>\nSymbol<\/th>\nCode<\/th>\nSymbol<\/th>\nCode<\/th>\nSymbol<\/th>\n<\/tr>\n
0<\/td>\nNUL (null)<\/td>\n32<\/td>\n(space)<\/td>\n64<\/td>\n@<\/td>\n96<\/td>\n`<\/td>\n<\/tr>\n
1<\/td>\nSOH (start of header)<\/td>\n33<\/td>\n!<\/td>\n65<\/td>\nA<\/td>\n97<\/td>\na<\/td>\n<\/tr>\n
2<\/td>\nSTX (start of text)<\/td>\n34<\/td>\n\u201d<\/td>\n66<\/td>\nB<\/td>\n98<\/td>\nb<\/td>\n<\/tr>\n
3<\/td>\nETX (end of text)<\/td>\n35<\/td>\n#<\/td>\n67<\/td>\nC<\/td>\n99<\/td>\nc<\/td>\n<\/tr>\n
4<\/td>\nEOT (end of transmission)<\/td>\n36<\/td>\n$<\/td>\n68<\/td>\nD<\/td>\n100<\/td>\nd<\/td>\n<\/tr>\n
5<\/td>\nENQ (enquiry)<\/td>\n37<\/td>\n%<\/td>\n69<\/td>\nE<\/td>\n101<\/td>\ne<\/td>\n<\/tr>\n
6<\/td>\nACK (acknowledge)<\/td>\n38<\/td>\n&<\/td>\n70<\/td>\nF<\/td>\n102<\/td>\nf<\/td>\n<\/tr>\n
7<\/td>\nBEL (bell)<\/td>\n39<\/td>\n\u2019<\/td>\n71<\/td>\nG<\/td>\n103<\/td>\ng<\/td>\n<\/tr>\n
8<\/td>\nBS (backspace)<\/td>\n40<\/td>\n(<\/td>\n72<\/td>\nH<\/td>\n104<\/td>\nh<\/td>\n<\/tr>\n
9<\/td>\nHT (horizontal tab)<\/td>\n41<\/td>\n)<\/td>\n73<\/td>\nI<\/td>\n105<\/td>\ni<\/td>\n<\/tr>\n
10<\/td>\nLF (line feed\/new line)<\/td>\n42<\/td>\n*<\/td>\n74<\/td>\nJ<\/td>\n106<\/td>\nj<\/td>\n<\/tr>\n
11<\/td>\nVT (vertical tab)<\/td>\n43<\/td>\n+<\/td>\n75<\/td>\nK<\/td>\n107<\/td>\nk<\/td>\n<\/tr>\n
12<\/td>\nFF (form feed \/ new page)<\/td>\n44<\/td>\n,<\/td>\n76<\/td>\nL<\/td>\n108<\/td>\nl<\/td>\n<\/tr>\n
13<\/td>\nCR (carriage return)<\/td>\n45<\/td>\n-<\/td>\n77<\/td>\nM<\/td>\n109<\/td>\nm<\/td>\n<\/tr>\n
14<\/td>\nSO (shift out)<\/td>\n46<\/td>\n.<\/td>\n78<\/td>\nN<\/td>\n110<\/td>\nn<\/td>\n<\/tr>\n
15<\/td>\nSI (shift in)<\/td>\n47<\/td>\n\/<\/td>\n79<\/td>\nO<\/td>\n111<\/td>\no<\/td>\n<\/tr>\n
16<\/td>\nDLE (data link escape)<\/td>\n48<\/td>\n0<\/td>\n80<\/td>\nP<\/td>\n112<\/td>\np<\/td>\n<\/tr>\n
17<\/td>\nDC1 (data control 1)<\/td>\n49<\/td>\n1<\/td>\n81<\/td>\nQ<\/td>\n113<\/td>\nq<\/td>\n<\/tr>\n
18<\/td>\nDC2 (data control 2)<\/td>\n50<\/td>\n2<\/td>\n82<\/td>\nR<\/td>\n114<\/td>\nr<\/td>\n<\/tr>\n
19<\/td>\nDC3 (data control 3)<\/td>\n51<\/td>\n3<\/td>\n83<\/td>\nS<\/td>\n115<\/td>\ns<\/td>\n<\/tr>\n
20<\/td>\nDC4 (data control 4)<\/td>\n52<\/td>\n4<\/td>\n84<\/td>\nT<\/td>\n116<\/td>\nt<\/td>\n<\/tr>\n
21<\/td>\nNAK (negative acknowledge)<\/td>\n53<\/td>\n5<\/td>\n85<\/td>\nU<\/td>\n117<\/td>\nu<\/td>\n<\/tr>\n
22<\/td>\nSYN (synchronous idle)<\/td>\n54<\/td>\n6<\/td>\n86<\/td>\nV<\/td>\n118<\/td>\nv<\/td>\n<\/tr>\n
23<\/td>\nETB (end of transmission block)<\/td>\n55<\/td>\n7<\/td>\n87<\/td>\nW<\/td>\n119<\/td>\nw<\/td>\n<\/tr>\n
24<\/td>\nCAN (cancel)<\/td>\n56<\/td>\n8<\/td>\n88<\/td>\nX<\/td>\n120<\/td>\nx<\/td>\n<\/tr>\n
25<\/td>\nEM (end of medium)<\/td>\n57<\/td>\n9<\/td>\n89<\/td>\nY<\/td>\n121<\/td>\ny<\/td>\n<\/tr>\n
26<\/td>\nSUB (substitute)<\/td>\n58<\/td>\n:<\/td>\n90<\/td>\nZ<\/td>\n122<\/td>\nz<\/td>\n<\/tr>\n
27<\/td>\nESC (escape)<\/td>\n59<\/td>\n;<\/td>\n91<\/td>\n[<\/td>\n123<\/td>\n{<\/td>\n<\/tr>\n
28<\/td>\nFS (file separator)<\/td>\n60<\/td>\n<<\/td>\n92<\/td>\n\\ <\/td>\n124<\/td>\n|<\/td>\n<\/tr>\n
29<\/td>\nGS (group separator)<\/td>\n61<\/td>\n=<\/td>\n93<\/td>\n]<\/td>\n125<\/td>\n}<\/td>\n<\/tr>\n
30<\/td>\nRS (record separator)<\/td>\n62<\/td>\n><\/td>\n94<\/td>\n^<\/td>\n126<\/td>\n~<\/td>\n<\/tr>\n
31<\/td>\nUS (unit separator)<\/td>\n63<\/td>\n?<\/td>\n95<\/td>\n_<\/td>\n127<\/td>\nDEL (delete)<\/td>\n<\/tr>\n
<\/table><\/div>\n
Codes 0-31 and 127 are called the unprintable chars.  These codes were designed to control peripheral devices such as printers (e.g. by instructing the printer how to move the print head).  Most of these are obsolete now.  If you try to print these chars, the results are dependent upon your OS (you may get some emoji-like characters).<\/p>\n
Codes 32-126 are called the printable characters, and they represent the letters, number characters, and punctuation that most computers use to display basic English text.<\/p>\n
If you try to print a character whose value is outside the range of ASCII, the results are also dependent upon your OS.<\/p>\n
Initializing chars<\/p>\n
You can initialize char variables using character literals:<\/p>\n
char ch2{ 'a' }; \/\/ initialize with code point for 'a' (stored as integer 97) (preferred)<\/code><\/pre>\n
You can initialize chars with integers as well, but this should be avoided if possible<\/p>\n
char ch1{ 97 }; \/\/ initialize with integer 97 ('a') (not preferred)<\/code><\/pre>\n
\n
Warning<\/p>\n
Be careful not to mix up character numbers with integer numbers.  The following two initializations are not the same:<\/p>\n
char ch{5}; \/\/ initialize with integer 5 (stored as integer 5)\r\nchar ch{'5'}; \/\/ initialize with code point for '5' (stored as integer 53)<\/code><\/pre>\n
Character numbers are intended to be used when we want to represent numbers as text, rather than as numbers to apply mathematical operations to.\n<\/p><\/div>\n
Printing chars<\/p>\n
When using std::cout to print a char, std::cout outputs the char variable as an ASCII character:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    char ch1{ 'a' }; \/\/ (preferred)\r\n    std::cout << ch1; \/\/ cout prints character 'a'\r\n\r\n    char ch2{ 98 }; \/\/ code point for 'b' (not preferred)\r\n    std::cout << ch2; \/\/ cout prints a character ('b')\r\n\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
This produces the result:<\/p>\n
\r\nab\r\n<\/pre>\n
We can also output char literals directly:<\/p>\n
std::cout << 'c';<\/code><\/pre>\n
This produces the result:<\/p>\n
\r\nc\r\n<\/pre>\n
Inputting chars<\/p>\n
The following program asks the user to input a character, then prints out the character:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    std::cout << \"Input a keyboard character: \";\r\n\r\n    char ch{};\r\n    std::cin >> ch;\r\n    std::cout << \"You entered: \" << ch << '\\n';\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
Here’s the output from one run:<\/p>\n
\r\nInput a keyboard character: q\r\nYou entered: q\r\n<\/pre>\n
Note that std::cin will let you enter multiple characters.  However, variable ch<\/em> can only hold 1 character.  Consequently, only the first input character is extracted into variable ch<\/em>.  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.<\/p>\n
You can see this behavior in the following example:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    std::cout << \"Input a keyboard character: \"; \/\/ assume the user enters \"abcd\" (without quotes)\r\n\r\n    char ch{};\r\n    std::cin >> ch; \/\/ ch = 'a', \"bcd\" is left queued.\r\n    std::cout << \"You entered: \" << ch << '\\n';\r\n\r\n    \/\/ Note: The following cin doesn't ask the user for input, it grabs queued input!\r\n    std::cin >> ch; \/\/ ch = 'b', \"cd\" is left queued.\r\n    std::cout << \"You entered: \" << ch << '\\n';\r\n    \r\n    return 0;\r\n}<\/code><\/pre>\n
\nInput a keyboard character: abcd\r\nYou entered: a\r\nYou entered: b\r\n<\/pre>\n
If you want to read in more than one char at a time (e.g. to read in a name, word, or sentence), you’ll want to use a string instead of a char.  A string is a collection of sequential characters (and thus, a string can hold multiple symbols).  We discuss this in upcoming lesson (5.7 -- Introduction to std::string<\/a>).<\/p>\n
Extracting whitespace characters<\/p>\n
Because extracting input ignores leading whitespace, this can lead to unexpected results when trying to extract whitespace characters to a char variable:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    std::cout << \"Input a keyboard character: \"; \/\/ assume the user enters \"a b\" (without quotes)\r\n\r\n    char ch{};\r\n    std::cin >> ch; \/\/ extracts a, leaves \" b\\n\" in stream\r\n    std::cout << \"You entered: \" << ch << '\\n';\r\n\r\n    std::cin >> ch; \/\/ skips leading whitespace (the space), extracts b, leaves \"\\n\" in stream\r\n    std::cout << \"You entered: \" << ch << '\\n';\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
\nInput a keyboard character: a b\r\nYou entered: a\r\nYou entered: b\r\n<\/pre>\n
In the above example, we may have expected to extract the space, but because leading whitespace is skipped, we extracted the b<\/code> character instead.<\/p>\n
One simple way to address this is to use the std::cin.get()<\/code> function to perform the extraction instead, as this function does not ignore leading whitespace:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    std::cout << \"Input a keyboard character: \"; \/\/ assume the user enters \"a b\" (without quotes)\r\n\r\n    char ch{};\r\n    std::cin.get(ch); \/\/ extracts a, leaves \" b\\n\" in stream\r\n    std::cout << \"You entered: \" << ch << '\\n';\r\n\r\n    std::cin.get(ch); \/\/ extracts space, leaves \"b\\n\" in stream\r\n    std::cout << \"You entered: \" << ch << '\\n';\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
\nInput a keyboard character: a b\r\nYou entered: a\r\nYou entered:  \r\n<\/pre>\n
Char size, range, and default sign<\/p>\n
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).<\/p>\n
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.<\/p>\n
Escape sequences<\/p>\n
There are some sequences of characters in C++ that have special meaning.  These characters are called escape sequences<\/strong>.  An escape sequence starts with a ‘\\’ (backslash) character, and then a following letter or number.<\/p>\n
You’ve already seen the most common escape sequence: '\\n'<\/code>, which can be used to print a newline:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    int x { 5 };\r\n    std::cout << \"The value of x is: \" << x << '\\n'; \/\/ standalone \\n goes in single quotes\r\n    std::cout << \"First line\\nSecond line\\n\";        \/\/ \\n can be embedded in double quotes\r\n    return 0;\r\n}<\/code><\/pre>\n
This outputs:<\/p>\n
\r\nThe value of x is: 5\r\nFirst line\r\nSecond line\r\n<\/pre>\n
Another commonly used escape sequence is '\\t'<\/code>, which embeds a horizontal tab:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    std::cout << \"First part\\tSecond part\";\r\n    return 0;\r\n}<\/code><\/pre>\n
Which outputs:<\/p>\n
\r\nFirst part\tSecond part\r\n<\/pre>\n
Three other notable escape sequences are:
\n\\’ prints a single quote
\n\\” prints a double quote
\n\\\\ prints a backslash<\/p>\n
Here’s a table of all of the escape sequences:<\/p>\n
<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Name<\/th>\nSymbol<\/th>\nMeaning<\/th>\n<\/tr>\n
Alert<\/td>\n\\a<\/td>\nMakes an alert, such as a beep<\/td>\n<\/tr>\n
Backspace<\/td>\n\\b<\/td>\nMoves the cursor back one space<\/td>\n<\/tr>\n
Formfeed<\/td>\n\\f<\/td>\nMoves the cursor to next logical page<\/td>\n<\/tr>\n
Newline<\/td>\n\\n<\/td>\nMoves cursor to next line<\/td>\n<\/tr>\n
Carriage return<\/td>\n\\r<\/td>\nMoves cursor to beginning of line<\/td>\n<\/tr>\n
Horizontal tab<\/td>\n\\t<\/td>\nPrints a horizontal tab<\/td>\n<\/tr>\n
Vertical tab<\/td>\n\\v<\/td>\nPrints a vertical tab<\/td>\n<\/tr>\n
Single quote<\/td>\n\\’<\/td>\nPrints a single quote<\/td>\n<\/tr>\n
Double quote<\/td>\n\\”<\/td>\nPrints a double quote<\/td>\n<\/tr>\n
Backslash<\/td>\n\\\\ <\/td>\nPrints a backslash.<\/td>\n<\/tr>\n
Question mark<\/td>\n\\?<\/td>\nPrints a question mark.
No longer relevant. You can use question marks unescaped.<\/td>\n<\/tr>\n
Octal number<\/td>\n\\(number)<\/td>\nTranslates into char represented by octal <\/p>\n
Hex number<\/td>\n\\x(number)<\/td>\nTranslates into char represented by hex number<\/td>\n<\/tr>\n
<\/table><\/div>\n
Here are some examples:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    std::cout << \"\\\"This is quoted text\\\"\\n\";\r\n    std::cout << \"This string contains a single backslash \\\\\\n\";\r\n    std::cout << \"6F in hex is char '\\x6F'\\n\";\r\n    return 0;\r\n}<\/code><\/pre>\n
Prints:<\/p>\n
\r\n\"This is quoted text\"\r\nThis string contains a single backslash \\\r\n6F in hex is char 'o'\r\n<\/pre>\n
\n
Warning<\/p>\n
Escape sequences start with a backslash (\\), not a forward slash (\/).  If you use a forward slash by accident, it may still compile, but will not yield the desired result.\n<\/p><\/div>\n
Newline (\\n) vs. std::endl<\/p>\n
We cover this topic in lesson 1.5 -- Introduction to iostream: cout, cin, and endl<\/a>.<\/p>\n
What’s the difference between putting symbols in single and double quotes?<\/p>\n
Text between single quotes is treated as a char<\/code> literal, which represents a single character.  For example, 'a'<\/code> represents the character a<\/code>, '+'<\/code> represents the character for the plus symbol, '5'<\/code> represents the character 5<\/code> (not the number 5), and  '\\n'<\/code> represents the newline character.<\/p>\n
Text between double quotes (e.g. “Hello, world!”) is treated as a C-style string literal, which can contain multiple characters.  We discuss strings in lesson 5.2 -- Literals<\/a>.<\/p>\n
\n
Best practice<\/p>\n
Single characters should usually be single-quoted, not double-quoted (e.g. 't'<\/code> or '\\n'<\/code>, not \"t\"<\/code> or \"\\n\"<\/code>).  One possible exception occurs when doing output, where it can be preferential to double quote everything for consistency (see lesson 1.5 -- Introduction to iostream: cout, cin, and endl<\/a>).\n<\/div>\n
Avoid multicharacter literals<\/p>\n
For backwards compatibility reasons, many C++ compilers support multicharacter literals<\/strong>, which are char literals that contain multiple characters (e.g. '56'<\/code>).  If supported, these have an implementation-defined value (meaning it varies depending on the compiler).  Because they are not part of the C++ standard, and their value is not strictly defined, multicharacter literals should be avoided.<\/p>\n
\n
Best practice<\/p>\n
Avoid multicharacter literals (e.g. '56'<\/code>).\n<\/div>\n
Multicharacter literal support often causes problems for new programmers when the forget whether escape sequences use forward slashes or backslashes:<\/p>\n
#include <iostream>\r\n\r\nint add(int x, int y)\r\n{\r\n\treturn x + y;\r\n}\r\n\r\nint main()\r\n{\r\n\tstd::cout << add(1, 2) << '\/n'; \/\/ we used a forward slash instead of a backslash here\r\n\r\n\treturn 0;\r\n}<\/code><\/pre>\n
The programmer expects this program to print the value 3<\/code> and a newline.  But instead, on the author’s machine, it outputs the following:<\/p>\n
\n312142\r\n<\/pre>\n
The issue here is that the programmer accidentally used '\/n'<\/code> (a multicharacter literal consisting of a forward slash and an 'n'<\/code> character) instead of '\\n'<\/code> (the escape sequence for a newline).  The program first prints 3<\/code> (the result of add(1, 2)<\/code>) correctly.  But then it prints the value of multicharacter literal '\/n'<\/code>, which on the author’s machine had the implementation-defined value 12142<\/code>.<\/p>\n
\n
Warning<\/p>\n
Make sure that your newlines are using escape sequence '\\n'<\/code> , not multicharacter literal '\/n'<\/code>.\n<\/div>\n
\n
Key insight<\/p>\n
Note that if we’d double-quoted the output \"\/n\"<\/code>, the program would have printed 3\/n<\/code>, which is still wrong, but much less confusing.\n<\/div>\n
Here’s another example.  Let’s start with the following:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    int x { 5 };\r\n    std::cout << \"The value of x is \" << x << '\\n'; \r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
This program outputs exactly as you expect:<\/p>\n
\nThe value of x is 5\r\n<\/pre>\n
But this output isn’t nearly exciting enough, so we decide to add an exclamation point before the newline:<\/p>\n
#include <iostream>\r\n\r\nint main()\r\n{\r\n    int x { 5 };\r\n    std::cout << \"The value of x is \" << x << '!\\n'; \/\/ added exclamation point\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
While we expect this to output the following:<\/p>\n
\nThe value of x is 5!\r\n<\/pre>\n
Because '!\\n'<\/code> is a multicharacter literal, on the author’s machine, this actually printed:<\/p>\n
\nThe value of x is 58458\r\n<\/pre>\n
This is not only incorrect, it can be hard to debug because you are likely to assume that x<\/code> has the wrong value.<\/p>\n
Using double quotes when outputting character literals (instead of single quotes) either makes these kind of issues easier to discover or avoids them entirely.<\/p>\n
What about the other char types, wchar_t<\/code>, char8_t<\/code>, char16_t<\/code>, and char32_t<\/code>?<\/p>\n
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 144,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).<\/p>\n
char16_t<\/code> and char32_t<\/code> were added to C++11 to provide explicit support for 16-bit and 32-bit Unicode characters.    These char types have the same size as std::uint_least16_t<\/code> and std::uint_least32_t<\/code> respectively (but are distinct types).  char8_t<\/code> was added in C++20 to provide support for 8-bit Unicode (UTF-8).  It is a distinct type that uses the same representation as unsigned char<\/code>.<\/p>\n
You won’t need to use char8_t<\/code>, char16_t<\/code>, or char32_t<\/code> unless you’re planning on making your program Unicode compatible.  wchar_t<\/code> should be avoided in almost all cases (except when interfacing with the Windows API), as its size is implementation-defined.<\/p>\n
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.<\/p>\n
\n\t\n 
\n    
<\/i><\/div>\n    
\n      
Next lesson<\/div>\n      
\n        4.12<\/span>Introduction to type conversion and static_cast\n      <\/div>\n    <\/div>\n  <\/div><\/a>\n  \t\n  
\n    
<\/i><\/div>\n    
\n      
Back to table of contents<\/div>\n    <\/div>\n<\/div><\/a>\n  \t\n  
\n    
<\/i><\/div>\n    
\n      
Previous lesson<\/div>\n      
\n        4.10<\/span>Introduction to if statements\n      <\/div>\n    <\/div>\n  <\/div><\/a>\n  <\/div><\/div>\n","protected":false},"excerpt":{"rendered":"
To this point, the fundamental data types we’ve looked at have been used to hold numbers (integers and floating points) or true\/false values (Booleans). But what if we want to store letters or punctuation? #include <iostream> int main() { std::cout << “Would you like a burrito? (y\/n)”; \/\/ We want …<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[3],"tags":[],"_links":{"self":[{"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/posts\/48"}],"collection":[{"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/comments?post=48"}],"version-history":[{"count":64,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/posts\/48\/revisions"}],"predecessor-version":[{"id":18261,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/posts\/48\/revisions\/18261"}],"wp:attachment":[{"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/media?parent=48"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/categories?post=48"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/tags?post=48"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}