ASCII codes are the numeric representation of every standard 7-bit character in C++. Each character—letters, digits, punctuation, and control codes—maps to a unique integer between 0 and 127. In C++, you use these codes whenever you need to manipulate individual characters, validate input, or perform low-level string operations. For example, the uppercase letter 'A' has an ASCII code of 65, while the lowercase 'a' is 97. Instead of memorizing these values, you can use an online ASCII table to look up any character’s decimal, hexadecimal, octal, and binary values instantly. This is especially useful when you’re working with legacy systems, network protocols, or embedded environments where raw byte values matter.

When you’re writing C++ code, you often need to convert between characters and their numeric codes. The simplest way is to cast a char to an int, which automatically returns its ASCII decimal value. For instance, int code = static_cast<int>('B'); assigns 66 to code. Conversely, you can cast an integer back to a character to get the symbol it represents. Hexadecimal values are frequently used in debugging, memory dumps, and binary file formats, so having a quick reference for 0x41 (65 in decimal) or 0x20 (the space character) saves time. The ASCII Table tool organizes all 128 codes in a searchable format, letting you filter by category—such as controls, punctuation, or digits—so you can isolate exactly what you need without scrolling through irrelevant entries.

Beyond basic character handling, ASCII codes are essential for tasks like parsing text files, implementing custom encodings, or interfacing with hardware that expects specific byte values. For example, if you’re reading a binary file that uses ASCII control characters to mark record separators, you’ll need to know that 0x1E (decimal 30) represents the "Record Separator" control. Similarly, when working with serial communication protocols, you might need to send a carriage return (0x0D) or line feed (0x0A) to signal the end of a command. The ASCII Table tool provides these values in multiple formats, so you can copy the exact number you need for your code, whether it’s 13 for decimal, 0x0D for hex, or 015 for octal.

how to use ascii code in c++
how to use ascii code in c++

Why You Need an ASCII Table for C++ Development

C++ doesn’t include a built-in reference for ASCII codes, so developers often resort to memorizing common values or searching online for tables that may be incomplete or poorly formatted. An online ASCII table eliminates this friction by providing a single, reliable source for all 128 standard codes. The tool’s search functionality lets you find values by character name (e.g., "space"), control abbreviation (e.g., "LF"), or numeric value in any radix. For example, if you’re debugging a string that contains non-printable characters, you can search for "char:0" to see all control codes at once. This is far more efficient than flipping through documentation or guessing which value corresponds to which character.

The ASCII Table tool also categorizes characters into logical groups, such as "Letters," "Digits," "Punctuation," and "Controls." This is particularly useful when you’re writing validation logic. For instance, if you need to check whether a character is a digit, you can quickly see that all digits fall between 48 ('0') and 57 ('9') in decimal. Similarly, uppercase letters range from 65 ('A') to 90 ('Z'), and lowercase letters from 97 ('a') to 122 ('z'). These ranges are easy to reference when you’re writing functions like isUpper() or isDigit() from scratch. The tool also includes the "Delete" character (127), which is often overlooked but critical in terminal-based applications.

Another advantage of using an online ASCII table is the ability to copy values directly into your code. Instead of manually typing 0x48 or 72, you can select the row for the character 'H' and click "Copy" to get the exact value you need. This reduces the risk of typos, especially when working with hexadecimal or octal values, which are prone to errors. The tool also displays the 7-bit binary representation of each character, which is helpful for bitwise operations or when you need to inspect individual bits in a byte. For example, if you’re implementing a parity check, you can use the binary value to count the number of set bits in a character.

How to Look Up ASCII Codes for C++

  1. Open the ASCII Table tool in your browser.
  2. Browse the full table of 128 rows or use the search box to find a specific character. You can search by:
    • Character name (e.g., "space" or "tab")
    • Control abbreviation (e.g., "LF" or "CR")
    • Decimal value (e.g., "65")
    • Prefixed radix value (e.g., "0x41" for hex or "0101" for octal)
    • Special syntax like char:0 or char:A
  3. Use the category filters to isolate specific groups of characters, such as "Controls," "Punctuation," "Digits," or "Letters." This is useful when you only need to see a subset of the table.
  4. Review the decimal, hexadecimal, octal, and binary values for the character you’re interested in. For example, the letter 'A' will show:
    Decimal Hexadecimal Octal Binary
    65 0x41 0101 01000001
  5. Click the "Copy" button on the row to copy the value in your preferred format. You can then paste it directly into your C++ code, such as char c = 65; or int code = 0x41;.
  6. Repeat the process for any additional characters you need. The tool retains your search and filter settings, so you can quickly look up multiple values without resetting.

Using ASCII Codes in C++ Code

Once you’ve looked up the ASCII codes you need, you can use them in your C++ programs in several ways. The most common approach is to cast between char and int to convert characters to their numeric values and vice versa. For example, the following code snippet prints the ASCII decimal value of the character 'B':

char ch = 'B';
int asciiValue = static_cast<int>(ch);
std::cout << "The ASCII value of '" << ch << "' is " << asciiValue << std::endl;

This outputs: The ASCII value of 'B' is 66. You can also use hexadecimal literals directly in your code. For instance, to assign the character 'H' to a variable, you could write:

char ch = 0x48;

This is equivalent to char ch = 'H'; or char ch = 72;. Hexadecimal values are particularly useful when working with binary data or memory addresses, as they align naturally with byte boundaries.

ASCII codes are also essential for character validation and manipulation. For example, if you’re writing a function to convert lowercase letters to uppercase, you can use the fact that the difference between 'a' and 'A' is 32 in ASCII. Here’s how you might implement it:

char toUpper(char c) {
    if (c >= 'a' && c <= 'z') {
        return c - 32;
    }
    return c;
}

In this function, c - 32 subtracts 32 from the ASCII value of the lowercase letter, converting it to its uppercase counterpart. The ASCII Table tool confirms that 'a' is 97 and 'A' is 65, so the difference is indeed 32. Similarly, you can check if a character is a digit by verifying if its ASCII value falls between 48 ('0') and 57 ('9').

For more advanced use cases, such as parsing binary files or implementing custom encodings, you might need to work with control characters. These include non-printable codes like "Start of Heading" (SOH, 0x01), "End of Transmission" (EOT, 0x04), and "Escape" (ESC, 0x1B). The ASCII Table tool lists all 33 control characters, along with their abbreviations and descriptions. For example, if you’re writing a terminal emulator, you might need to handle the "Bell" character (0x07), which triggers an audible alert. You can use the tool to find that the decimal value is 7, so you’d write std::cout << '\a'; or std::cout << static_cast<char>(7); to produce the bell sound.

Common C++ Tasks That Rely on ASCII Codes

ASCII codes are fundamental to many common C++ tasks, from simple input validation to complex string manipulation. One of the most frequent uses is checking whether a character is a letter, digit, or whitespace. For example, the following function checks if a character is a whitespace character by comparing it against the ASCII codes for space (32), tab (9), newline (10), carriage return (13), and form feed (12):

bool isWhitespace(char c) {
    return c == 32 || c == 9 || c == 10 || c == 13 || c == 12;
}

You can also use the ASCII Table tool to find the codes for other whitespace characters, such as vertical tab (11) or non-breaking space (160 in extended ASCII, though this is outside the 7-bit standard).

Another common task is converting strings between uppercase and lowercase. As mentioned earlier, the difference between 'a' and 'A' in ASCII is 32, so you can write a function to convert a string to lowercase like this:

std::string toLower(const std::string& str) {
    std::string result;
    for (char c : str) {
        if (c >= 'A' && c <= 'Z') {
            result += c + 32;
        } else {
            result += c;
        }
    }
    return result;
}

This function iterates over each character in the string and adds 32 to its ASCII value if it’s an uppercase letter. The ASCII Table tool confirms that 'A' (65) + 32 = 'a' (97), so the conversion is correct.

ASCII codes are also used in sorting and comparing strings. By default, C++ compares strings lexicographically based on the ASCII values of their characters. This means that uppercase letters (65–90) come before lowercase letters (97–122), and digits (48–57) come before letters. For example, the string "Apple" will sort before "apple" because 'A' (65) is less than 'a' (97). If you need case-insensitive sorting, you can convert all characters to the same case before comparing them. The ASCII Table tool helps you verify the relative ordering of characters, so you can write accurate comparison logic.

In network programming, ASCII codes are often used to parse and construct protocol messages. For example, HTTP headers are text-based and use ASCII characters to separate fields and values. The "Content-Length" header, for instance, is followed by a colon (0x3A) and a space (0x20), then the length as a decimal string. If you’re writing an HTTP client or server, you’ll need to know these codes to correctly parse incoming messages or format outgoing ones. The ASCII Table tool provides the exact values you need, such as 0x3A for colon and 0x20 for space.

Finally, ASCII codes are essential for working with binary data. When you read or write binary files, you’re often dealing with raw bytes that represent ASCII characters. For example, a binary file might use the ASCII code 0x1E (decimal 30) to mark the start of a new record. To read such a file, you’d need to check each byte for this value. The ASCII Table tool lets you look up these codes quickly, so you can implement the logic without guessing or memorizing values. For more complex binary formats, you might also need to work with extended ASCII (8-bit) or Unicode, but the 7-bit ASCII table remains the foundation for most character-based operations.

For additional C++ development tools, you might also find the JSON Formatter useful for debugging API responses, or the Regex Tester for validating string patterns. If you’re working with timestamps, the Unix Timestamp Converter can help you convert between human-readable dates and numeric values.

More on this topic: How to Use ASCII Code for Programming and Data Tasks.

Related reading: How to Generate Code Image From Text Locally.