Foundations — Type sizes — sizeof, platform dependency, stdint.h (int32_t etc.)

Before you can trust a single sentence of the parent note, you must be able to see what a "bit", a "byte", a "size", and a "type" actually are. This page builds each one from nothing, in the order they depend on each other, then shows you a map of how they feed the topic.

1. A bit — the single on/off switch

Picture it as a light switch on a wall. Down = $0$, up = $1$. That is the entire alphabet a computer has to write every number, letter, and image with.

Why the topic needs it: the whole idea of "how big is an int" is really "how many of these switches does it get." Sizes are counts of switches.

2. Counting with switches — why $N$ bits gives $2^N$ patterns

Line up several switches in a row. Each switch you add doubles the number of different arrangements, because for every old arrangement you now get two: "new switch off" and "new switch on."

Picture it: 1 switch → 2 pictures ($0,1$). 2 switches → 4 pictures ($00,01,10,11$). 3 switches → 8. The tree keeps splitting in two.

Why the topic needs it: this is exactly the derivation the parent uses to say an unsigned $N$-bit number goes from $0$ to $2^N-1$. If you don't feel why it doubles, the range formulas are just magic symbols.

3. A byte and the symbol $\ge$

The parent note writes the guarantee char ≥ 8 bits. That $\ge$ symbol means "greater than or equal to".

Picture it as a fence with a gate: $\le$ lets things through only up to a maximum height; the flat line under the arrow is the "equal is allowed too" part.

Why the topic needs it: C never says "char is exactly 8 bits." It says char ≥ 8. The $\ge$ is the legal loophole that lets a chip use bigger bytes. The whole "minimum width, not exact width" rule is built on this one symbol.

4. A type — the label that says how to read a box

Picture it as writing on the outside of a cardboard box: "8 slots, whole numbers only" vs "32 slots, can be negative." The bits inside are the same kind of switches; the label decides their meaning.

Why the topic needs it: char, short, int, long, long long are all just type labels, and this entire topic is about the fact that the label doesn't fix the box size — the platform does. Later the topic introduces labels like int32_t that do pin the size down; those are still just type labels, only stricter ones.

5. Signed vs unsigned — spending the top switch

Where does that lopsided range come from? Let's derive it instead of memorising it, using $N=3$ (8 patterns) as the picture.

We still have all $2^N$ switch patterns — nothing is thrown away. We just choose to read the top (leftmost) bit as a flag:

• Top bit $=0$ → the number is the ordinary count of the remaining $N-1$ bits: values $0,1,\dots ,2^{N-1}-1$. For $N=3$ that is $0,1,2,3$ — exactly $2^{N-1}=4$ patterns.
• Top bit $=1$ → the number is negative. These $2^{N-1}$ patterns are assigned to $-2^{N-1},\dots ,-1$. For $N=3$ that is $-4,-3,-2,-1$ — again exactly $4$ patterns.

Why exactly half each way? Because the top bit has only two settings, and fixing it uses up one switch, leaving $N-1$ free switches = $2^{N-1}$ patterns per side. So the $2^N$ patterns split cleanly into two equal halves: $2^{N-1}$ non-negative and $2^{N-1}$ negative.

Why is there no "negative zero"? Zero is stored once, with all bits off (top bit $0$), so it counts as part of the non-negative half. That is why the positive side stops one short — it holds $0$ through $2^{N-1}-1$ (that's $2^{N-1}$ values including zero), while the negative side gets a full $2^{N-1}$ genuinely-negative values reaching all the way down to $-2^{N-1}$. The lopsided-looking $-4\dots 3$ is really "one zero shared into the top half."

Picture it as a ruler. Unsigned puts $0$ at the far-left end and counts right. Signed slides $0$ so the top-bit-off patterns ($\mathrm{0..3}$) sit on the right and the top-bit-on patterns ($-\mathrm{4..}-1$) sit on the left — same $2^N$ marks, just relabelled.

Why the topic needs it: sizeof returns an unsigned value (size_t), and int32_t vs uint32_t is exactly this choice. It also explains why INT32_MAX is $2^{31}-1$ (the top-bit-off half, minus the shared zero) but UINT32_MAX is $2^{32}-1$ (the whole range). Deeper: Two's complement & integer overflow.

6. Dividing to count — the ruler idea behind sizeof

Picture it as pouring a big jug ($a$) into small identical cups ($b$): the number of full cups you can fill is $a÷b$.

Why the topic needs it: the parent's array-length trick $\text{sizeof a}÷\text{sizeof a[0]}=\frac{\text{total bytes}}{\text{bytes per element}}=\text{element count}$ is just this division. It gives a count that never mentions how big an int is — which is the whole point of using it. (It breaks only when the array has "decayed" to a pointer — see Pointers and array decay.)

7. The size_t label and %zu

Picture it as a measuring tape whose numbers only go up (never negative), long enough to reach across the biggest object you could ever build.

Why the topic needs it: sizeof hands you back a size_t. Printing it with the wrong tag is a classic bug the parent warns about. More at size_t and ptrdiff_t and printf format specifiers.

How these foundations feed the topic

The figure below is the same map drawn as a picture: follow the arrows upward-to-downward and each idea is built from the ones pointing into it.

Walk it in words: a bit is one switch; stacking switches gives $2^N$ patterns and groups of eight give a byte; the pattern count plus the signed/unsigned choice produce the value ranges; a type is the label on the box; sizeof is the ruler that measures the box; size_t is where the ruler's reading is stored; and the exact-width int32_t idea grows out of both "type label" and "value range." All of these pour into the Type sizes topic itself.

Equipment checklist

Cover the right side and answer out loud.