Visual walkthrough — Data types — char, short, int, long, float, double, size_t

We use only these three ideas, and we will earn each one:

• A bit = a switch that is either 0 (off) or 1 (on).
• A byte = 8 such switches sitting in a row.
• Counting: how many different arrangements those switches can make.

---

Step 1 — A byte is 8 switches in a row

WHAT. Look at the strip below. Memory is nothing but tiny switches. We draw one byte: eight little boxes, each showing a $0$ or a $1$. We call each box a bit (short for binary digit).

WHY. Before we can talk about ranges we must agree on the raw material. Everything — the number 65, the letter 'A', a piece of a float — lives as a pattern of these eight switches. The type is just the lens we choose later; right now there is no meaning at all, only on/off.

PICTURE. The eight boxes, numbered from bit $0$ on the right to bit $7$ on the left. Nothing means anything yet — that is the point.

---

Step 2 — How many patterns can 8 switches make?

WHAT. Each switch has $2$ choices. There are $8$ switches, and the choices are independent, so we multiply: $\underset{\text{bit }7}{\underbrace{2}}\times \underset{\text{bit }6}{\underbrace{2}}\times \cdots \times \underset{\text{bit }0}{\underbrace{2}}=2^8=256.$ Every factor of $2$ in that product is one switch. The exponent $8$ is literally the number of boxes.

WHY. This is the whole foundation of ranges. A type that owns $n$ bits can name exactly $2^n$ different things — not one more. If you want negative numbers, characters, or huge floats, they must all be carved out of this fixed budget of $256$ names.

PICTURE. A branching tree: bit $7$ splits into two paths, each splits again for bit $6$, and so on. Count the leaves at the bottom — there are $256$.

---

Step 3 — The unsigned lens: give each bit a place value

WHAT. Now we choose a lens. The unsigned lens says: every pattern is a plain, non-negative whole number. To read it, give bit $k$ the weight $2^k$ and add up the ones that are on: $\text{value}=b_7{2}^7+b_6{2}^6+\cdots +b_1{2}^1+b_0{2}^0.$ Here $b_k$ is the switch value ($0$ or $1$) and $2^k$ is its place value, exactly like the $1$s, $10$s, $100$s columns in decimal — but doubling instead of ten-ing.

WHY. We need a rule that turns switches into numbers, and this one is the simplest: it is ordinary place-value counting in base $2$. The largest number appears when all switches are on.

PICTURE. The byte 1100 1000 with each column labelled by its weight; the on-bits ($128$ and $64$ and $8$) are highlighted and summed to $200$.

---

Step 4 — Wrap-around: the number line is a circle

WHAT. What happens at $255$ if you add $1$? All eight switches are on ($11111111$); adding $1$ tries to carry past bit $7$, that carry falls off the edge, and every switch flips back to $0$. So $255+1\to 0$. The unsigned bytes do not sit on a straight line — they sit on a clock with $256$ ticks.

WHY. This "wrap" is not a bug you can avoid; it is a direct consequence of Step 2's fixed budget. There is no room to store $256$, so it silently becomes $0$. This is exactly the overflow behaviour that catches beginners.

PICTURE. A circle of $256$ ticks; $255$ sits just before $0$; a red arrow leaps from $255$ over the top back to $0$.

---

Step 5 — The signed lens: make the top bit worth a negative

WHAT. We still have $256$ patterns, but we want to name negatives too. The two's complement trick keeps every bit's weight the same — except the top bit, whose weight is made negative: $\text{value}=\underset{\text{now subtracts!}}{\underbrace{-b_7{2}^7}}+b_6{2}^6+\cdots +b_0{2}^0.$ Only one symbol changed: the $2^7$ became $-2^7$. That single minus sign turns the top switch into a "you owe $128$" flag.

WHY. This is the lens C actually uses for signed char, int, etc. (see Two's Complement Representation). It is chosen because ordinary binary addition just works on it — the same adder circuit handles negatives with no special case. The pattern with only the top bit on ($10000000$) is now the value $-128$.

PICTURE. The same byte columns as Step 3, but the leftmost column is repainted red and relabelled $-128$. Two example patterns are read: $10000000=-128$ and $01111111=+127$.

---

Step 6 — The signed clock and the char c = 200 mystery

WHAT. Bend the signed bytes into a clock too, but label the ticks $-128\dots 0\dots 127$. Now trace what happens when we write char c = 200. The pattern is still 1100 1000 (Step 3 gave us $200$ unsigned). Read through the signed lens: the top bit is on, so it contributes $-128$ instead of $+128$: $-128+64+8=-56.$ Equivalently, $200$ is past $127$, so it wraps: $200-256=-56$.

WHY. This is the worked example from the parent, now seen: the bits never changed, only the lens. unsigned char u = 200 uses the Step 3 lens and stays $200$; char c = 200 uses the Step 5 lens and becomes $-56$. Same switches, two answers — the type is the interpretation (Type Conversion and Promotion governs which lens applies where).

PICTURE. The signed clock; a green arrow walks $200$ steps from $0$, sailing past $127$, over the top, and landing on $-56$.

---

Step 7 — Degenerate cases: $n=1$ and the empty budget

WHAT. Test the formulas at the extremes so no scenario surprises you.

• $n=1$ bit, unsigned: $[0,2^1-1]=[0,1]$. Two patterns, two values. ✔
• $n=1$ bit, signed: $[-2^0,2^0-1]=[-1,0]$. The single bit's weight is $-2^0=-1$, so the two patterns mean $0$ and $-1$. No room for $+1$ at all — the lopsidedness taken to its limit.
• All bits zero (any $n$): value $=0$ under both lenses (nothing is switched on, and $-b_{\text{top}}{2}^{\dots }$ is also $0$). Zero looks the same signed or unsigned.

WHY. Formulas that only work for "nice" sizes hide bugs. Checking $n=1$ confirms the signed formula's lopsidedness is real (one negative, zero positives) and that $0$ is the shared fixed point of both lenses.

PICTURE. Two tiny two-tick number lines side by side: unsigned $\{0,1\}$ and signed $\{-1,0\}$, with the shared $0$ circled.

Recall Why does

size_t never hit these negatives? Because sizeof measures a size, which is inherently $\ge 0$. size_t is unsigned (Step 3 lens only), so it uses the full $[0,2^n-1]$ and can never wrap into a negative — which is exactly why size_t i; i >= 0 loops forever.

---

The one-picture summary

WHAT. One diagram fuses the whole derivation: the fixed budget of $2^n$ patterns (Step 2), split into two possible lenses — unsigned (Step 3, straight from $0$ up) and signed (Step 5, top bit flipped negative) — each closing into a clock (Steps 4 & 6), with the shared fixed point $0$.

Recall Feynman retelling (say it to a 12-year-old)

Picture eight light-switches in a row. Each is on or off, so together they can strike $2^8=256$ different patterns — no more, because there are only eight switches. Now we decide what a pattern means. The easy way ("unsigned"): give each switch a doubling value $1,2,4,8,\dots ,128$ and add up the ones that are on — this counts from $0$ up to $255$. But we also want minus numbers. Trick: keep every switch's value the same except the leftmost, which we make worth $-128$. Now the same $256$ patterns run from $-128$ up to $+127$ — one extra negative because zero already took a spot on the plus side. Whichever meaning we pick, if you go past the biggest value you fall off the edge and wrap around, like a clock. So when C stores $200$ in a plain char, the switches read 11001000; through the minus-$128$ lens that's $-128+64+8=-56$. The bits never lied — we just looked through a different lens.

---

Active Recall

Recall Cover and answer

• Why $2^n$ patterns? ::: $n$ independent switches, each with $2$ choices, multiplied.
• Why is unsigned max $2^n-1$? ::: zero eats one of the $2^n$ names.
• What single change turns the unsigned lens into the signed one? ::: the top bit's weight becomes $-2^{n-1}$.
• Why one more negative than positive? ::: zero sits on the positive side, using a slot.
• Signed value of pattern 1100 1000? ::: $-128+64+8=-56$.
• Signed 1-bit range? ::: $[-1,0]$.