Visual walkthrough — Unions — overlapping memory

We start with the most literal thing a computer has: a row of numbered boxes.

Step 1 — Memory is a numbered row of 1-byte boxes

WHAT. Before we talk about unions at all, we need to agree on what "memory" even is. In C, memory is a long line of tiny boxes. Each box holds exactly one byte (8 bits, a number from 0 to 255). Each box has an address — box 0, box 1, box 2, and so on.

WHY start here. Every claim about unions ("they overlap", "size = largest") is really a claim about which boxes a member occupies. If we don't have the boxes drawn, the rest is hand-waving.

PICTURE. Below, the row of white boxes is memory. The cyan numbers under them are addresses. Notice the little bracket labelled "offset 0" — that is where our story begins for every union member.

Step 2 — A variable claims a run of boxes; its type says HOW MANY

WHAT. When you declare a variable, C reserves a run of consecutive boxes for it. How many boxes? That is what the sizeof operator reports. A char grabs 1 box, an int grabs 4 boxes, a double grabs 8 boxes (on the common 64-bit setup we'll assume throughout).

WHY this matters. A union is about sharing boxes between members. To see sharing, we first must see each member's own footprint — its length in boxes.

PICTURE. Three separate runs, drawn to scale. Read each equation right on the drawing:

$\underset{\text{how many boxes a char needs}}{\underbrace{\text{sizeof(char)}}}=1,\text{sizeof(int)}=4,\text{sizeof(double)}=8$

Each symbol here is just "number of boxes this type occupies." The char fills 1 box; the int fills 4; the double fills 8.

Step 3 — A struct lines the members up SIDE BY SIDE (the thing a union is NOT)

WHAT. To appreciate a union, look first at its opposite, the struct. A struct gives each member its own run of boxes, placed one after another. Nothing overlaps.

WHY show the contrast. The single most common mistake (from the parent note's "Mistake 2") is expecting a union to behave like a struct — summing sizes. Seeing them side by side kills that reflex.

PICTURE. The char sits in box 0, then the int starts later, then the double later still. The total width is the sum (plus padding, shown as amber gaps):

$\text{sizeof(struct)}=\underset{1}{\underbrace{s_{\text{char}}}}+\underset{4}{\underbrace{s_{\text{int}}}}+\underset{8}{\underbrace{s_{\text{double}}}}+\underset{\text{padding}}{\underbrace{p}}$

Here $s_m$ means "size of member $m$ in boxes," and $p$ is the padding C inserts so each member lands on a legal address.

Step 4 — A union STACKS all members onto the SAME boxes (offset 0)

WHAT. Now the union. Instead of side by side, every member starts at the same first box — offset 0. They are drawn stacked on top of each other, all pointing at the identical boxes.

WHY. This is the defining property. There is no separate room per member; there is one room, and each member is just a different interpretation of the boxes in that room.

PICTURE. Look at the three coloured bars: the char covers box 0 only; the int covers boxes 0–3; the double covers boxes 0–7. They all start at the same left edge (the amber "offset 0" arrow). They are transparent overlays on the same memory, not neighbours.

$\text{start address of every member}=0$

That single equation — "everyone starts at 0" — is the whole idea of a union.

Step 5 — Because everyone starts at 0, the union must be as wide as the WIDEST member

WHAT. Here is the parent's central result, derived. Since member $m$ occupies boxes $0$ through $s_m-1$, the union must reserve enough boxes to satisfy the worst case — the member that reaches furthest right.

WHY this exact formula. We take a max, not a sum, precisely because the members overlap. Where a struct pays for every member, a union pays only once, for the greediest one. Everything smaller fits inside that reserved space.

PICTURE. The double (8 boxes) is the tallest bar; the int and char fit entirely within its width. The union's outline is drawn to hug the widest bar:

$\text{size}(U)=\text{align}\left(\underset{\text{the greediest member}}{\underbrace{\underset{m}{\max }{s}_m}}\right)$

• ${\max }_m{s}_m$ — scan all members, keep the largest box-count (here $8$, the double).
• $\text{align}(\cdot )$ — round that number up until it is a multiple of the strictest member's alignment requirement, so an array of these unions keeps every element correctly aligned.

For union { char c; int i; double d; }: $\max =8$, and $8$ is already a multiple of $8$, so sizeof = 8.

Step 6 — Writing one member OVERWRITES the shared boxes

WHAT. Since all members share boxes 0…, storing into member A changes the very boxes member B reads. There is no separate copy to fall back on.

WHY. This follows directly from Step 4. If two members point at box 0, then whoever wrote last owns box 0. Reading the other member now reads the last writer's bits — not its own.

PICTURE. Two frames. Frame 1: we do d.i = 65, so boxes 0–3 hold the integer pattern for 65. Frame 2: we do d.f = 3.14f, and the same boxes 0–3 are painted with the float's bit pattern. The old integer is simply gone.

union Data d;
d.i = 65;            // boxes 0..3 = int bits of 65
d.f = 3.14f;         // SAME boxes 0..3 = float bits of 3.14
printf("%d\n", d.i); // garbage — reads float bits AS an int

Step 7 — The degenerate & edge cases (nothing left unshown)

WHAT. We handle the corners the earlier steps glossed over.

WHY. The contract: the reader must never meet a scenario we didn't draw.

Case A — all members the same size. union { int i; float f; }: both are 4 boxes, so $\max =4$ and every member fills the entire union. Overlap is total.

Case B — a member needs padding to align. union { char c; double d; }: $\max =8$ from the double. Even though char is 1 box, the union is 8 boxes, so an array of these unions keeps every double on an 8-aligned address. The extra boxes past the char are unused when c is active — but reserved.

Case C — default initialization. union Data d = {65}; sets only the first member (d.i = 65). Reading any other member afterward reads whatever bit pattern 65 makes — meaningless as a float. (Parent's Mistake 3.)

Case D — reading the lowest byte (endianness). With union { int i; char c[4]; } u; u.i = 65; on a little-endian machine, the lowest-order byte 0x41 lands in box 0, so u.c[0] == 'A' (ASCII 65). On a big-endian machine that byte would land in box 3 instead.

PICTURE. Each case as its own labelled memory strip, amber marking the "active/used" boxes and cyan marking "reserved but dead" boxes.

The one-picture summary

Everything above compressed into a single diagram: memory as boxes → members stacked at offset 0 → size = the widest bar → writing repaints shared boxes.

Connections

• Parent: Unions — overlapping memory
• Structs — separate memory for each member
• Memory alignment and padding
• Endianness — byte order
• Type punning and bit-level reinterpretation
• Enums
• sizeof operator