🔧 C Programming · Chapter 2

Variables, types and how many bytes they take

In Python a variable is a label on a value. In C a variable IS the box — a fixed number of bytes at a fixed address — and the type decides how many.

Study this lesson free in the app →

The basics

A variable in C is a named piece of memory. Its type fixes two things forever: how many bytes it occupies and how those bytes are read — as a whole number, a decimal, or a character.

The problem it solves: the CPU only sees bytes. The type is how you tell the compiler what the bytes mean, so it can pick the right instructions and reserve the right amount of space.

The mental model: rows of numbered lockers. int fare = 250; rents 4 adjacent lockers, writes 250 into them in binary, and calls the group fare. int total = fare; rents 4 more lockers and copies the bytes. Change fare later and total doesn't move. This is the opposite of Python's luggage tags.

Explained

int x; — what is x?

In most languages, "nothing yet". In C, it's whatever bytes were left in that memory by the last function that used it. It might be 0 on your laptop and 32767 in production.

Understanding types as bytes is the whole of C. Pointers, arrays, strings and structs are all built on this one idea.

Lockers at a railway station

Chennai Central has a wall of numbered lockers, each exactly one byte wide.

• A char rents 1 locker.
• An int rents 4 lockers side by side.
• A double rents 8.

Your ticket says "lockers 1000–1003, read as a whole number". That's the type. The same 4 lockers read as a decimal (float) give a completely different value, because the bytes are identical and the reading is not.

Copying a variable means renting new lockers and copying the contents across. And a locker you rent but never fill still holds whatever the previous traveller left in it.

The types and their sizes

Typical 64-bit Linux/macOS (sizeof in bytes):

| Type | Bytes | Range / use | | --- | --- | --- | | char | 1 | always 1 — one byte, also a small integer | | short | 2 | −32,768 … 32,767 | | int | 4 | ≈ ±2.1 billion | | long | 8 | 4 on Windows — don't rely on it | | long long | 8 | ≈ ±9.2 × 10¹⁸ | | float | 4 | ~7 significant digits | | double | 8 | ~15–16 digits — the default for decimals |

Add unsigned to drop negatives and double the positive range: an unsigned int holds 0 … 4,294,967,295.

The C standard guarantees only minimums, such as "int is at least 16 bits". When the exact size matters (file formats, network data, hashing), use <stdint.h>: int32_t, uint8_t, int64_t. Those are exact.

Ask the machine, don't memorise

#include <stdio.h>
#include <stdint.h>

int main(void) {
    printf("char   %zu\n", sizeof(char));
    printf("int    %zu\n", sizeof(int));
    printf("long   %zu\n", sizeof(long));
    printf("double %zu\n", sizeof(double));
    printf("int64  %zu\n", sizeof(int64_t));

    int fare = 250;
    double km = 12.5;
    char grade = 'A';
    printf("%d %.1f %c %d\n", fare, km, grade, grade);
    return 0;          // last line: 250 12.5 A 65
}

sizeof gives a size_t, and its specifier is %zu. The last printf prints grade twice: as a character (A) and as a number (65). A char is just a 1-byte integer; 'A' is another way to write 65.

What memory actually looks like

int fare = 250;      char g = 'A';      double km = 12.5;

address  1000 1001 1002 1003   1004   1008 ......... 1015
        ┌────┬────┬────┬────┐ ┌────┐ ┌──────────────────┐
bytes   │ FA │ 00 │ 00 │ 00 │ │ 41 │ │  8 bytes, IEEE754 │
        └────┴────┴────┴────┘ └────┘ └──────────────────┘
         └──── fare: int ───┘  g:char      km: double

250 = 0xFA. On x86 and ARM the lowest byte comes first (little-endian), so the bytes read FA 00 00 00.

'A' = 65 = 0x41.

The gap between 1005 and 1007 is padding: the compiler lines up double on an 8-byte boundary. (Exact addresses vary; the shape doesn't.)

The float that wasn't equal

float f = 0.1f;
if (f == 0.1)
    printf("same\n");
else
    printf("different\n");

Gotchas

• Reading an uninitialised local. int count; count++; is a bug, not 1. Always initialise: int count = 0;.
• The wrong printf specifier. printf("%d", 3.5) prints garbage, because printf reads the bytes the way you told it to. %d int, %ld long, %lld long long, %u unsigned, %f double, %c char, %zu size_t. -Wall catches these.
• Assuming long is 8 bytes. It's 4 on Windows. Use int64_t when you need 64 bits.
• 'A' vs "A". Single quotes: one char (a number, 65). Double quotes: a string, which is two bytes, A and \0.
• Money in float. Use integer paise.

A variable is a fixed-size box of bytes. The type says how many bytes and how to read them.

= copies the bytes. An uninitialised box holds garbage. When in doubt, sizeof it.

Words to know

In two minutes

• A C variable is a fixed-size block of memory; the type sets the size and how the bytes are read.
• Typical sizes: char 1, short 2, int 4, long long 8, float 4, double 8. long is 8 on Linux/macOS but 4 on Windows.
• Use <stdint.h> (int32_t, uint8_t, int64_t) when the exact width matters.
• Assignment copies bytes; two variables never share storage.
• Uninitialised local variables hold garbage. Globals and statics start at zero.
• char is a 1-byte integer: 'A' is 65.
• printf reads bytes according to the specifier, so a wrong specifier means wrong output.
• Never compare floats with ==, and keep money in integer paise.

Test yourself

There are 9 questions, 3 puzzles and 5 recall cards for this lesson in the app — the recall cards come back on later days, just before you would forget.