Characters and ASCII

Every character you see on screen is secretly a number. Understanding this idea is key to working with text in C - and to understanding security problems that can happen when handling text.

The char Type

A char holds one character - one letter, digit, or symbol. It takes up one byte of memory (8 bits), which can hold values from 0 to 255.

char letter = 'A';
char digit = '7';
char symbol = '@';

Notice the single quotes. This is important:

• 'A' is a single character (the letter A, stored as the number 65)
• "A" is a string (we will cover this in Part 5 - it is different!)

Characters Are Numbers

Here is the key idea: char is just a small number. When you store 'A', you are actually storing the number 65.

char letter = 'A';
printf("Character: %c\n", letter);   // Prints: A
printf("Number: %d\n", letter);      // Prints: 65

This means you can do math with characters:

char letter = 'A';
letter = letter + 1;    // Now letter is 'B' (66)
letter = letter + 25;   // Now letter is 'Z' (90)

ASCII: The Character-to-Number Mapping

ASCII (American Standard Code for Information Interchange) is the standard that defines which number represents which character. It covers values 0-127.

Quick Reference: The Important Parts

You do not need to memorize the full ASCII table. Just remember these key ranges - you can always look up the rest:

That is it! These four ranges cover most of what you will need day-to-day.

Key Ranges to Know

Here is a more detailed breakdown:

The Critical Difference: '\0' vs '0'

This confuses everyone at first, and getting it wrong causes serious bugs:

char null_char = '\0';   // ASCII 0 - the string terminator
char zero_digit = '0';   // ASCII 48 - the character "0"

// These are completely different!
if (null_char == zero_digit) {
    printf("Same\n");     // This will NEVER print
} else {
    printf("Different\n"); // This WILL print
}

The null character '\0' marks where strings end in C. We will cover this in detail in Part 5.

The Full ASCII Table

The tables below list every ASCII character. These are reference tables - you do not need to memorize them. Bookmark this page and come back when you need to look something up.

Control Characters (0-31)

These are invisible characters that tell the computer to do things like start a new line or make a beep sound. You cannot see them on screen, but they still exist in your text.

Printable Characters (32-126)

These are the characters you can actually see - letters, numbers, and symbols.

Delete Character (127)

Useful Patterns

Converting Between Cases

Uppercase and lowercase letters differ by exactly 32:

char upper = 'A';           // 65
char lower = upper + 32;    // 97 = 'a'

char c = 'g';               // 103
char C = c - 32;            // 71 = 'G'

You can also use bitwise operations (these flip individual bits in the number). Bit 5 is the one that controls whether a letter is uppercase or lowercase:

char c = 'G';
c = c | 32;    // Force lowercase: 'g' (set bit 5)
c = c & ~32;   // Force uppercase: 'G' (clear bit 5)
c = c ^ 32;    // Toggle case (flip bit 5)

Checking Character Types

char c = '7';

// Is it a digit?
if (c >= '0' && c <= '9') {
    int value = c - '0';  // Convert char '7' to int 7
    printf("Digit with value: %d\n", value);
}

// Is it uppercase?
if (c >= 'A' && c <= 'Z') {
    printf("Uppercase letter\n");
}

// Is it lowercase?
if (c >= 'a' && c <= 'z') {
    printf("Lowercase letter\n");
}

// Is it a letter?
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
    printf("Letter\n");
}

The standard library (built-in C code you can use) provides helpful functions in <ctype.h>:

#include <ctype.h>

char c = 'A';
isdigit(c);   // 0 (false) - not a digit
isalpha(c);   // non-zero (true) - is a letter
isupper(c);   // non-zero (true) - is uppercase
islower(c);   // 0 (false) - not lowercase
isspace(c);   // 0 (false) - not whitespace
toupper(c);   // 'A' (already upper)
tolower(c);   // 'a'

Converting Digit Characters to Numbers

The character '5' is not the number 5 - it is the number 53 (its ASCII value). To get the actual number:

char digit = '7';
int value = digit - '0';  // 55 - 48 = 7

// Going the other way:
int num = 3;
char c = num + '0';  // 3 + 48 = 51 = '3'

Escape Sequences

Some characters cannot be typed directly on your keyboard (like “newline” or “tab”). C uses backslash escape sequences to represent them:

You can also specify any character by its octal or hex value:

char newline = '\n';     // Using escape sequence
char newline2 = '\012';  // Using octal (012 = 10)
char newline3 = '\x0A';  // Using hex (0A = 10)
// All three are identical

Extended ASCII (128-255)

Standard ASCII only defines characters 0-127 (7 bits). But a char is 8 bits, which can hold values 0-255. The characters 128-255 are called “Extended ASCII.”

Here’s the problem: There is no single agreed-upon standard for Extended ASCII. Different computers and operating systems used different mappings for these extra characters:

This caused chaos. A file written on one system would display garbage on another. The character at position 200 might be È on one system and ╚ on another.

Extended ASCII Table (ISO-8859-1 / Latin-1)

This table shows ISO-8859-1, also called “Latin-1” - the most common extended ASCII for Western languages. Again, this is just a reference - no need to memorize it.

Unicode: The Modern Solution

The Extended ASCII mess was a real problem. Imagine writing an email in French on your computer, then your friend in Japan opens it and sees garbage characters. That happened all the time!

Unicode fixed this by creating one big list that gives every character in every language its own unique number - over 150,000 characters and counting. It includes letters from every alphabet, plus things like Chinese characters and even emojis.

What you need to know for now:

1. UTF-8 is how most computers store Unicode text today. The good news: characters 0-127 work exactly like ASCII, so all your ASCII code still works.

2. Text handling gets tricky. For example, Turkish has four different “I” letters (I, ı, İ, i), not just two like English. Code that assumes uppercase of 'i' is always 'I' will mess up Turkish text.

3. C was not designed for Unicode. For now, stick with basic ASCII characters (the ones in this lesson). When you need to handle text from different languages, you will need to learn about special libraries.

If you want to learn more later, see unicode.org.

Try It Yourself

1. Write a program that prints the ASCII table from 32-126
2. Write a function that converts a lowercase letter to uppercase (without using toupper)
3. Write a function that takes a digit character (‘0’-‘9’) and returns its numeric value
4. What does 'A' + 'a' equal? Calculate it, then verify with code.

Common Mistakes

• Confusing '\0' and '0': The null character (value 0) vs the digit zero (value 48) - this trips up everyone at first!
• Confusing char and int: They are both numbers, but char only holds values 0-255
• Forgetting single quotes: A is a variable name, 'A' is the character A
• Assuming all text is ASCII: Characters from other languages use different systems

Next Up

In Part 4, we will learn about bitwise operations - how to manipulate individual bits for low-level programming tasks like flags, permissions, and efficient calculations.

Enjoyed This?

If this helped something click, subscribe to my YouTube channel. More content like this, same approach - making things stick without insulting your intelligence. It’s free, it helps more people find this stuff, and it tells me what’s worth making more of.