ASCII Table — Complete Chart of Codes, Characters & Symbols

ASCII stands for the American Standard Code for Information Interchange. It was first published in 1963 by the American Standards Association (now ANSI) and revised in 1967 and 1986; the original character assignments are preserved in RFC 20, still the canonical reference for the 7-bit set. Despite being over 60 years old, ASCII is far from obsolete: the first 128 code points of UTF-8 — the dominant text encoding on the modern web — are identical to ASCII, which is why plain ASCII text is also valid UTF-8.

ASCII is a 7-bit character code, so each character is represented by a unique combination of 7 bits. That gives 2⁷ = 128 possible codes (0–127). Of these, 33 are non-printable control codes (0–31 and 127, DEL) originally designed to control hardware such as printers and teletypes, and the remaining 95 are printable characters — letters, digits, punctuation and the space.

• List of all ASCII Characters and Description
• Printable vs Non-Printable Characters
• Extended ASCII (128–255)
• How to Use the ASCII Table
  • Typing ASCII Characters with Alt Codes (Windows)
• C Program to Print ASCII Characters
• C++ Program to Print ASCII Characters
• Python Program to Print ASCII Characters
• C# Program to Print ASCII Characters
• Frequently Asked Questions
• References

List of all ASCII Characters and Description

Printable vs Non-Printable Characters

ASCII characters fall into two groups:

• Control characters (0–31 and 127): non-printable codes that signal actions rather than display a glyph — for example carriage return (13), line feed (10), tab (9), escape (27) and delete (127).
• Printable characters (32–126): the space, digits, uppercase and lowercase letters, and punctuation you can actually see on screen.

This is why the programs below substitute a blank space for any value below 32 or equal to 127 — those codes have no printable glyph.

Extended ASCII (128–255)

Standard ASCII only defines codes 0–127. Values 128–255 are often called “extended ASCII,” but there is no single extended-ASCII standard — what a value such as 200 displays depends entirely on the active code page. Common encodings include ISO-8859-1 (Latin-1) and Windows-1252. This ambiguity is the classic cause of mojibake — the garbled “é” characters you see when a file saved in one code page is opened as another. For anything beyond code 127, prefer a defined encoding such as UTF-8.

How to Use the ASCII Table

• Character ↔ code conversion: look up a character’s decimal value (e.g. A = 65) when comparing or sorting characters in code.
• Escape sequences: common control codes appear in code as escapes — \n is line feed (10), \t is tab (9), \0 is null (0).
• Case conversion: uppercase and lowercase letters are exactly 32 apart (A=65, a=97), so flipping case is a single arithmetic operation.
• Alt codes (Windows): hold Alt and type the decimal code on the numeric keypad to insert a character — e.g. Alt+64 = @, Alt+169 = ©.

Typing ASCII Characters with Alt Codes (Windows)

On Windows, you can type any character by holding the Alt key and entering its decimal code on the numeric keypad (Num Lock on), then releasing Alt. This is useful for symbols that aren’t printed on your keyboard.

Codes 0–127 use plain Alt + number. Codes prefixed with 0 (e.g. Alt + 0169) tell Windows to use the Windows-1252 code page, which is how you reach characters above 127 such as ©, ® and €.

C Program to Print ASCII Characters

This program prints the ASCII character table. The program displays each character’s Decimal, Octal, Hexadecimal, Binary, and Symbol representation. It uses a loop to iterate through all 128 ASCII values (0 to 127) and formats the output into neatly aligned columns. If you are new to the language, our C programming tutorials walk through the fundamentals from the ground up.

The program also replaces non-printable ASCII characters (values 0–31 and 127) with a blank space (' ') to avoid displaying unprintable symbols.

#include <stdio.h>
void printBinary(int num, char *binStr) {
    for (int i = 7; i >= 0; i--) {
        binStr[7 - i] = (num & (1 << i)) ? '1' : '0';
    }
    binStr[8] = '\0'; // Null-terminate the string
}
int main() {
    printf("Decimal Number\tOCT Number\tHEX Number\tBIN Number\tSymbol\n");
    for (int i = 0; i < 128; i++) {
        char bin[9]; // Array to hold the binary string (8 bits + null terminator)
        printBinary(i, bin);
        // Replace non-printable characters with a blank space
        char symbol = (i >= 32 && i <= 126) ? i : ' ';
        printf("%d\t\t%03o\t\t%02X\t\t%s\t\t%c\n", i, i, i, bin, symbol);
    }
    return 0;
}

Notice the program splits the binary conversion into its own reusable routine — see our guide to functions in C for how and why to structure code this way.

A subtle trap in C: char may be signed, so casting values above 127 to char can produce negative numbers. Use unsigned char when working with the 128–255 range.

C++ Program to Print ASCII Characters

This C++ program generates and displays the ASCII character table in a structured format. It lists each ASCII character’s Decimal, Octal, Hexadecimal, Binary, and Symbol representations. The program is designed to iterate through all 128 ASCII values (from 0 to 127) and outputs the information in aligned columns for readability.

This example uses C++20’s std::format, so compile with -std=c++20 (GCC 13+, Clang 17+, or MSVC 2022).

#include <iostream>
#include <bitset>
#include <format>
#include <string>

int main() {
    std::cout << std::format("{:<15}{:<15}{:<15}{:<20}{:<10}\n",
                              "Decimal", "OCT Number", "HEX Number", "BIN Number", "Symbol");

    for (int i = 0; i < 128; ++i) {
        std::string binary = std::bitset<8>(i).to_string();

        char symbol = (i >= 32 && i <= 126)
                      ? static_cast<char>(i)
                      : ' ';

        std::cout << std::format("{:<15}{:<15o}{:<15X}{:<20}{:<10}\n",
                                 i, i, i, binary, std::string(1, symbol));
    }

    return 0;
}

The C++ version above uses std::bitset and the C++20 std::format library; if you want a refresher on the language itself, see our complete guide to C++ programming.

Python Program to Print ASCII Characters

The program uses Python’s format function to convert each ASCII value into an 8-bit binary representation.

# Function to generate an 8-bit binary representation
def to_binary(num):
    return format(num, '08b')

# Print the header
print(f"{'Decimal Number':<15}{'OCT Number':<12}{'HEX Number':<12}{'BIN Number':<12}{'Symbol':<10}")

# Iterate through all 128 ASCII characters
for i in range(128):
    decimal = i  # Decimal representation
    octal = format(i, '03o')  # Octal representation
    hexadecimal = format(i, '02X')  # Hexadecimal representation in uppercase
    binary = to_binary(i)  # Binary representation
    symbol = chr(i) if 32 <= i <= 126 else ' '  # Display symbol or blank for non-printable characters
    
    # Print the row
    print(f"{decimal:<15}{octal:<12}{hexadecimal:<12}{binary:<12}{symbol:<10}")

C# Program to Print ASCII Characters

using System;

class AsciiTable
{
    // Method to convert an integer to 8-bit binary string
    public static string ToBinary(int num)
    {
        return Convert.ToString(num, 2).PadLeft(8, '0');
    }

    public static void Main()
    {
        // Print the header
        Console.WriteLine("{0,-15}{1,-12}{2,-12}{3,-12}{4,-10}", 
                          "Decimal Number", "OCT Number", "HEX Number", "BIN Number", "Symbol");

        // Iterate through all 128 ASCII characters
        for (int i = 0; i < 128; i++)
        {
            int decimalValue = i;  // Decimal representation
            string octal = Convert.ToString(i, 8);  // Octal representation
            string hexadecimal = Convert.ToString(i, 16).ToUpper();  // Hexadecimal representation in uppercase
            string binary = ToBinary(i);  // Binary representation
            // Display symbol or blank for non-printable characters
            string symbol = (i >= 32 && i <= 126) ? ((char)i).ToString() : " ";  

            // Print the row with proper formatting
            Console.WriteLine("{0,-15}{1,-12}{2,-12}{3,-12}{4,-10}", 
                              decimalValue, octal, hexadecimal, binary, symbol);
        }
    }
}

In practice, the single most common encoding bug I see is treating bytes 128–255 as ‘ASCII’ — a file written as Windows-1252 and read as Latin-1 will silently corrupt curly quotes, em-dashes and accented letters.

Frequently Asked Questions

References

• https://www.britannica.com/topic/ASCII
• https://home.unicode.org/