The Complete ASCII Table, All 128 Rows

A computer stores numbers. Only numbers. So how does it store the letter A?

It agrees on a code. In 1963 a standard wrote the agreement down: A is 65, B is 66, and so on to 127. Its name is the American Standard Code for Information Interchange, ASCII for short. Every machine that follows it reads the same byte the same way.

This lesson is a reference page with the whole agreement printed in it, and five short programs that use it.

One byte, two readings

In C, a char is not really a letter. It is a small integer that you have agreed to show on the screen as a letter.

That is why the same variable can be printed two ways. %c says "show me the character this number stands for". %d says "show me the number".

#include <stdio.h>

int main(void)
{
    char letter = 'A';

    printf("As a character: %c\n", letter);
    printf("As a number:    %d\n", letter);
    return 0;
}

As a character: A
As a number:    65

Nothing was converted between those two lines. The byte in memory never changed. Only the lens you looked at it through changed.

The four anchors and the three tricks

You do not need to learn 128 numbers. You need four, and everything else follows by arithmetic.

From those four, three tricks cover most of the real work you will do with characters.

1. Change case by 32. A small letter is exactly 32 above its capital, so 'a' - 'A' is 32.
2. Digit character to digit value: subtract '0'. '7' - '0' is 7, because 55 minus 48 is 7.
3. Letter to alphabet position: subtract 'A' or 'a'. 'D' - 'A' is 3, so D is the fourth letter.

Notice what all three have in common. You never write 48, 65 or 97 in your code. You write '0', 'A' or 'a', and the compiler fills the number in, which keeps the line readable.

So if you can subtract, you can do case conversion, digit parsing and alphabet positions without a single library function.

The control characters: 0 to 31, and 127

The first 32 codes are not printable. They are control characters: commands left over from teleprinters, machines that typed text down a wire. Most are museum pieces. Five still matter, and they are in bold.

The five in bold are the ones you will actually type. NUL ends a string, HT is \t and LF is \n. CR is the other half of a Windows line ending, and ESC starts the codes that colour a terminal.

So a text file with no control characters in it at all would be one endless line.

The printable half: 32 to 126, complete

Everything from 32 to 126 has a shape you can see. Read the table in four blocks, left to right. The first cell of the first block is the space character, which is why it looks empty.

Three patterns are worth seeing in the table itself. The digits sit together, the capitals sit together, and the small letters sit together, each group unbroken.

Look at 65 and 97. The gap between a capital and its small letter is 32 on every row, which is trick one, visible.

Look at 48 and 57. The digits are in order with no gaps, which is what makes trick two work for every digit and not just for '7'.

Beyond ASCII, and what that means for Bangla

ASCII only defines 0 to 127, because it was designed for seven bits. A byte holds eight, so codes 128 to 255 were left free and every vendor filled them differently. That mess is called "extended ASCII" and it is why the same file looked like nonsense on a different machine.

Unicode fixed it by giving every character in every script its own number, and UTF-8 is the way those numbers are stored as bytes. ASCII is the first 128 of them, unchanged, which is why old files still work.

Here is the part that matters for you. In UTF-8, one Bangla letter takes three bytes, not one. The word "ঢাকা" is four letters and twelve bytes, and strlen answers 12.

So a char holds one byte, not one letter. The three tricks work on ASCII letters and digits. They do not work on Bangla text, because there is no single number to add 32 to. Real Bangla text handling is a Module 10 topic and needs a library.

#include <stdio.h>

int main(void)
{
    char letter = 'A';

    printf("As a character: %c\n", letter);
    printf("As a number:    %d\n", letter);
    printf("Add 1:          %c\n", letter + 1);
    printf("Add 32:         %c\n", letter + 32);
    return 0;
}

As a character: A
As a number:    65
Add 1:          B
Add 32:         a

#include <stdio.h>

int main(void)
{
    char upper = 'M';
    char lower = 'q';

    /* A small letter is exactly 32 above its capital. */
    printf("%c becomes %c\n", upper, upper + 32);
    printf("%c becomes %c\n", lower, lower - 32);
    return 0;
}

M becomes m
q becomes Q

#include <stdio.h>

int main(void)
{
    char digit = '7';

    int wrong = digit;           /* 55, the ASCII code */
    int right = digit - '0';     /* 7, the value it stands for */

    printf("Wrong: %d\n", wrong);
    printf("Right: %d\n", right);
    printf("Squared: %d\n", right * right);
    return 0;
}

Wrong: 55
Right: 7
Squared: 49

#include <stdio.h>

int main(void)
{
    for (int code = 32; code <= 126; code++) {
        printf("%3d %c", code, code);

        /* Start a new line after every eighth entry. */
        if ((code - 31) % 8 == 0) {
            printf("\n");
        } else {
            printf("   ");
        }
    }
    printf("\n");
    return 0;
}

 32      33 !    34 "    35 #    36 $    37 %    38 &    39 '
 40 (    41 )    42 *    43 +    44 ,    45 -    46 .    47 /
 48 0    49 1    50 2    51 3    52 4    53 5    54 6    55 7
 56 8    57 9    58 :    59 ;    60 <    61 =    62 >    63 ?
 64 @    65 A    66 B    67 C    68 D    69 E    70 F    71 G
 72 H    73 I    74 J    75 K    76 L    77 M    78 N    79 O
 80 P    81 Q    82 R    83 S    84 T    85 U    86 V    87 W
 88 X    89 Y    90 Z    91 [    92 \    93 ]    94 ^    95 _
 96 `    97 a    98 b    99 c   100 d   101 e   102 f   103 g
104 h   105 i   106 j   107 k   108 l   109 m   110 n   111 o
112 p   113 q   114 r   115 s   116 t   117 u   118 v   119 w
120 x   121 y   122 z   123 {   124 |   125 }   126 ~

char digit = '7';
printf("%d\n", digit);        /* prints 55, not 7 */

char d = '5';
printf("[%c]\n", d - 32);     /* prints [ ] with an invisible control char */

char c = 'ঢ';
printf("%d\n", c);

char c = 300;
printf("%d\n", c);            /* prints 44 */

printf("%d\n", 'a' + 'b');
printf("[%c]\n", 'a' + 'b');

#include <stdio.h>

int main(void)
{
    char ch;
    scanf("%c", &ch);

    /* One printf. Which specifier do you need? */

    return 0;
}

#include <stdio.h>

int main(void)
{
    char ch;
    scanf("%c", &ch);

    /* Trick one. Write the 32 as a difference of two characters if you can. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    char a, b, c;
    scanf("%c%c%c", &a, &b, &c);

    /* Trick two, three times. */

    return 0;
}

Next you will write code another human can read. It is the one skill in this module the compiler will never check for you.