Visual walkthrough — Unions — overlapping memory

5.1.24 · D2 · Coding › C Programming › Unions — overlapping memory

Hum sabse literal cheez se shuru karte hain jo ek computer ke paas hoti hai: numbered boxes ki ek row.

Step 1 — Memory ek numbered row of 1-byte boxes hai

KYA HAI. Unions ki baat karne se pehle, hume agree karna hoga ki "memory" actually hoti kya hai. C mein, memory choti choti boxes ki ek lambi line hai. Har box mein exactly one byte hota hai (8 bits, 0 se 255 tak ka ek number). Har box ka ek address hota hai — box 0, box 1, box 2, aur aage bhi.

YAHAN SE KYUN SHURU KAREIN. Unions ke baare mein har claim ("yeh overlap karte hain", "size = largest") asal mein yeh claim hai ki ek member kaun se boxes occupy karta hai. Agar boxes draw nahi hain, toh baaki sab haath hilana hi hai.

PICTURE. Neeche, safed boxes ki row memory hai. Unke neeche cyan numbers addresses hain. Woh chota bracket dekho jis par "offset 0" likha hai — yahi se har union member ki kahani shuru hoti hai.

Step 2 — Ek variable boxes ka ek run claim karta hai; uska type batata hai KITNE

KYA HAI. Jab tum ek variable declare karte ho, C uske liye consecutive boxes ka ek run reserve karta hai. Kitne boxes? Yahi sizeof operator report karta hai. Ek char 1 box leta hai, ek int 4 boxes leta hai, ek double 8 boxes leta hai (us common 64-bit setup par jo hum poore time assume karenge).

YAHAN KYA MATTER KARTA HAI. Ek union members ke beech boxes share karne ke baare mein hai. Sharing dekhne ke liye, pehle hume har member ka apna footprint dekhna hoga — boxes mein uski length.

PICTURE. Teen alag alag runs, scale ke saath drawn. Har equation drawing par padho:

$\underset{\text{ek char ko kitne boxes chahiye}}{\underbrace{\text{sizeof(char)}}}=1,\text{sizeof(int)}=4,\text{sizeof(double)}=8$

Yahan har symbol bas "is type ko kitne boxes chahiye" hai. char 1 box fill karta hai; int 4 fill karta hai; double 8 fill karta hai.

Step 3 — Ek struct members ko SIDE BY SIDE lagaata hai (woh cheez jo union NAHI hai)

KYA HAI. Union appreciate karne ke liye, pehle uska opposite dekho, yani struct. Ek struct har member ko apne boxes ka run deta hai, ek ke baad ek rakha jaata hai. Kuch bhi overlap nahi karta.

CONTRAST KYUN DIKHAYEIN. Sabse common galti (parent note ki "Mistake 2" se) yeh hai ki union se struct jaisa behaviour expect karna — sizes ko sum karna. Inhe side by side dekhne se woh reflex khatam ho jaata hai.

PICTURE. char box 0 mein baitha hai, phir int baad mein shuru hota hai, phir double aur baad mein. Total width sum hai (plus padding, amber gaps ke roop mein dikhaya gaya):

$\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}}$

Yahan $s_m$ ka matlab hai "member $m$ ka boxes mein size," aur $p$ woh padding hai jo C insert karta hai taaki har member ek legal address par land kare.

Step 4 — Ek union saare members ko SAME boxes par STACK karta hai (offset 0)

KYA HAI. Ab union. Side by side ki jagah, har member usi pehle box se shuru hota hai — offset 0. Inhe ek doosre ke upar stack kiya hua draw kiya jaata hai, sab ek hi identical boxes ki taraf point karte hue.

KYUN. Yahi defining property hai. Har member ke liye alag room nahi hota; ek hi room hota hai, aur har member bas us room ke boxes ki ek alag interpretation hota hai.

PICTURE. Teen coloured bars dekho: char sirf box 0 cover karta hai; int boxes 0–3 cover karta hai; double boxes 0–7 cover karta hai. Sab ek hi left edge se shuru hote hain (amber "offset 0" arrow). Yeh ek hi memory par transparent overlays hain, neighbours nahi.

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

Woh ek equation — "sabka start 0 par hai" — yahi union ka poora idea hai.

Step 5 — Kyunki sabka start 0 par hai, union SABSE WIDE member jitna wide hona chahiye

KYA HAI. Yeh parent ka central result hai, derived kiya gaya. Kyunki member $m$, boxes $0$ se $s_m-1$ tak occupy karta hai, union ko worst case — jo member sabse zyada right tak pahunche — satisfy karne ke liye kaafi boxes reserve karne padte hain.

YEH EXACT FORMULA KYUN. Hum max lete hain, sum nahi, exactly isliye kyunki members overlap karte hain. Jahan ek struct har member ke liye pay karta hai, ek union sirf ek baar, sabse greedy member ke liye pay karta hai. Usse chota sab kuch us reserved space ke andar fit ho jaata hai.

PICTURE. double (8 boxes) sabse tall bar hai; int aur char poori tarah uski width ke andar fit ho jaate hain. Union ka outline sabse wide bar ko hug karne ke liye draw kiya gaya hai:

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

• ${\max }_m{s}_m$ — saare members scan karo, sabse bada box-count rakho (yahan $8$, double).
• $\text{align}(\cdot )$ — us number ko upar round karo jab tak yeh strictest member ki alignment requirement ka multiple na ho jaaye, taaki in unions ke ek array mein har element sahi se aligned rahe.

union { char c; int i; double d; } ke liye: $\max =8$, aur $8$ pehle se $8$ ka multiple hai, isliye sizeof = 8.

Step 6 — Ek member mein likhna shared boxes ko OVERWRITE kar deta hai

KYA HAI. Kyunki saare members boxes 0… share karte hain, member A mein store karna ek hi boxes ko badal deta hai jo member B read karta hai. Koi alag copy nahi hoti jis par fall back kiya ja sake.

KYUN. Yeh seedha Step 4 se follow hota hai. Agar do members box 0 ki taraf point karte hain, toh jo last mein likha woh box 0 ka malik hai. Doosra member ab last writer ke bits padhta hai — apne nahi.

PICTURE. Do frames. Frame 1: hum d.i = 65 karte hain, toh boxes 0–3 mein 65 ka integer pattern hai. Frame 2: hum d.f = 3.14f karte hain, aur wahi boxes 0–3 float ke bit pattern se paint ho jaate hain. Purana integer bas gone hai.

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 — Degenerate aur edge cases (kuch bhi na dikhaya hua na rahe)

KYA HAI. Hum woh corners handle karte hain jinhe pehle ke steps ne gloss over kiya.

KYUN. Contract yeh hai: reader ko kabhi aisa scenario nahi milna chahiye jo humne draw nahi kiya.

Case A — saare members same size ke. union { int i; float f; }: dono 4 boxes hain, toh $\max =4$ aur har member poore union ko fill karta hai. Overlap total hai.

Case B — ek member ko align karne ke liye padding chahiye. union { char c; double d; }: double se $\max =8$. Bhale hi char 1 box hai, union 8 boxes ka hai, taaki in unions ke ek array mein har double ek 8-aligned address par ho. c active hone par char ke baad ke extra boxes unused hain — lekin reserved hain.

Case C — default initialization. union Data d = {65}; sirf pehle member ko set karta hai (d.i = 65). Baad mein kisi doosre member ko padhna 65 jo bit pattern banata hai woh padhta hai — float ke roop mein meaningless. (Parent ki Mistake 3.)

Case D — lowest byte padhna (endianness). union { int i; char c[4]; } u; u.i = 65; ke saath little-endian machine par, lowest-order byte 0x41 box 0 mein land karta hai, toh u.c[0] == 'A' (ASCII 65). Big-endian machine par woh byte box 3 mein land karta.

PICTURE. Har case apni labelled memory strip ke roop mein, amber "active/used" boxes mark karta hai aur cyan "reserved but dead" boxes mark karta hai.

Ek-picture summary

Upar sab kuch ek single diagram mein compress kiya gaya: memory as boxes → members offset 0 par stacked → size = sabse wide bar → likhna shared boxes ko repaint karta hai.

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