Enumerations: Worked examples — Hinglish deep dive

5.1.25 · D3 · Coding › C Programming › Enumerations

Yeh page ek shooting range hai: hum har tarah ki enum situation list karte hain jo C aapke saamne rakh sakta hai, phir har ek ko fully worked example se knock down karte hain. Agar aapne abhi tak nahi dekha ki enums kaise count karte hain, toh pehle parent note padho: Enumerations.

Shuru karne se pehle, ek promise us parent note se jo hum baar baar use karenge:

Neeche sab kuch is hi rule ka application hai, lekin increasingly tricky inputs par.

Scenario matrix

Samjho ki har enum jo aap kabhi bhi milenge woh in cells mein se kisi ek mein land karti hai. Hamara kaam hai inhe saare hit karna.

#	Case class	Kya tricky hai	Kaun cover karta hai
A	Pure defaults	seedha 0,1,2,… counting	Ex 1
B	Explicit start, phir resume	+1 rule kisi bhi number se continue hoti hai	Ex 2
C	Negative explicit value	counting abhi bhi +1 hai, zero se neeche se	Ex 3
D	Duplicate values	do naam, ek integer — legal hai	Ex 4
E	Zero / empty-ish & sentinel	trailing `COUNT` ek array ko size karta hai	Ex 5
F	Out-of-range assignment	`enum c = 99;` — "no type safety" ka edge case	Ex 6
G	Real-world word problem	enum vs magic numbers mein se choose karna	Ex 7
H	Exam twist — mixed `=` aur gaps	poori chain haath se trace karo	Ex 8

Neeche Cells A–H har ek label ki gayi hain. Saath milke yeh defaults, explicit, resumed, negative, duplicate, zero/sentinel, degenerate/out-of-range, real-world, aur exam-style cover karti hain — koi bhi scenario chhuta nahi.

Neeche figure woh mental model dikhati hai jo hum har jagah use karte hain: number line par named sticky-notes.

Worked examples

Worked example Ex 1 — Cell A: pure defaults

enum Planet { MERCURY, VENUS, EARTH, MARS };
printf("%d %d\n", EARTH, MARS);

Forecast: aage padhne se pehle do printed numbers guess karo.

MERCURY pehla hai aur koi = nahi, isliye yeh $0$ hai. Yeh step kyun? Rule kehta hai pehla un-initialised enumerator $0$ hota hai.
VENUS = 0 + 1 = 1, EARTH = 1 + 1 = 2, MARS = 2 + 1 = 3. Yeh step kyun? Baad mein har plain enumerator previous $+ 1$ hota hai.
printf("%d %d", EARTH, MARS) stored ints print karta hai, names nahi. Yeh step kyun? Ek enum constant runtime par ek int hi hota hai; C ke paas koi name table nahi hai.

Verify: ungliyon par 0,1,2,3 count karo → EARTH = 2, MARS = 3. Output: 2 3. ✅

Worked example Ex 2 — Cell B: explicit start, phir resume

enum Http { OK = 200, CREATED, ACCEPTED, MOVED = 301, NOTFOUND };
printf("%d %d %d\n", CREATED, ACCEPTED, NOTFOUND);

Forecast: teen numbers — inhe likh lo.

OK = 200 (explicit). "Previous value" ab $200$ hai. Yeh step kyun? Explicit = woh anchor set karta hai jisse +1 rule count karta hai.
CREATED = 200 + 1 = 201, ACCEPTED = 201 + 1 = 202. Yeh step kyun? Koi = nahi, isliye plain +1 continue hoti hai.
MOVED = 301 (explicit) anchor reset karta hai; NOTFOUND = 301 + 1 = 302. Yeh step kyun? +1 rule kabhi nahi rukti — yeh bas newest explicit value se resume hoti hai.

Verify: 201, 202, 302. Output: 201 202 302. ✅ (Note: mnemonic — "explicit can restart".)

Worked example Ex 3 — Cell C: negative explicit value

enum Temp { FREEZING = -3, T_A, T_B, T_C };
printf("%d %d %d\n", T_A, T_B, T_C);

Forecast: kya +1 tab bhi kaam karta hai jab hum zero se neeche shuru karein? Teen values guess karo.

FREEZING = -3 (explicit, negative). Anchor $- 3$ hai. Yeh step kyun? Explicit values koi bhi constant integer ho sakti hain, including negatives.
T_A = -3 + 1 = -2, T_B = -2 + 1 = -1, T_C = -1 + 1 = 0. Yeh step kyun? "Previous par +1" number line par arithmetic hai — yeh negatives mein se upar chalti hai, zero se guzarti hai, bina kisi special case ke.

Verify: number line par $- 3 \to - 2 \to - 1 \to 0$ . Output: -2 -1 0. ✅ Count 0 se guzarta hai — wahan kuch magic nahi hota.

Worked example Ex 4 — Cell D: duplicate values (dono legal hain)

enum Sev { INFO = 0, WARN = 5, ERR, FATAL = 5 };
printf("%d %d %d\n", ERR, FATAL, (WARN == FATAL));

Forecast: kya WARN == FATAL compile hoga? Yeh kya print karega?

INFO = 0, WARN = 5 (explicit). Anchor $5$ . Yeh step kyun? Standard explicit assignment.
ERR = 5 + 1 = 6. Yeh step kyun? WARN ke baad plain +1.
FATAL = 5 (explicit) — WARN jitna hi integer. Yeh allowed hai. Yeh step kyun? "Unique hona chahiye" ka rule names par apply hota hai, values par nahi. Do names ek integer share kar sakte hain.
WARN == FATAL compare karta hai $5 == 5$ → true → 1 print karta hai. Yeh step kyun? Yeh bas ints hain; equal ints equal compare hote hain.

Verify: ERR = 6, FATAL = 5, comparison = 1. Output: 6 5 1. ✅

Worked example Ex 5 — Cell E: zero-based sentinel ek array size karta hai

enum { SUN, MON, TUE, WED, THU, FRI, SAT, DAY_COUNT };
int steps[DAY_COUNT];
printf("%d\n", DAY_COUNT);       // array kitna bada hai?
printf("%zu\n", sizeof(steps) / sizeof(steps[0]));

Forecast: steps mein kitne elements hain?

SUN = 0 … SAT = 6 +1 rule se (7 real days, indices 0–6). Yeh step kyun? Standard default counting; aakhri real item $6$ par land karta hai.
DAY_COUNT = 6 + 1 = 7. Yeh koi real day nahi hai — yeh ek sentinel hai jo "pehle kitne aaye" ke barabar hota hai. Yeh step kyun? Last mein bina = ke rakha gaya, ek sentinel automatically preceding enumerators ki count ke barabar hota hai. Ek din add karo → count apne aap update hoti hai (dekho Arrays in C).
int steps[DAY_COUNT] matlab int steps[7] hai. sizeof se element count $7 \times 4/4 = 7$ hai (4-byte int assume karke — dekho Integer Types in C). Yeh step kyun? sizeof(array)/sizeof(element) classic array-length idiom hai.

Verify: DAY_COUNT = 7, aur array 7 ints hold karta hai. Output: 7 phir 7. ✅

Sentinel trick ek picture ki haqdar hai — aakhri note ek tally hai, koi din nahi:

Worked example Ex 6 — Cell F: degenerate / out-of-range assignment

enum Color { RED, GREEN, BLUE };   // 0,1,2
enum Color c = 99;                 // kya yeh compile bhi hoga?
printf("%d\n", c);

Forecast: compile error, warning, ya silent success?

RED=0, GREEN=1, BLUE=2 — valid "colours". Yeh step kyun? Default counting.
enum Color c = 99; compile hoga chahe 99 koi colour nahi hai. Yeh step kyun? C mein ek enum int se freely convertible hota hai — yahan almost koi type safety nahi hai. C aap par trust karta hai.
printf("%d", c) 99 print karta hai. Koi clamping nahi, koi wrap nahi, koi error nahi. Yeh step kyun? Variable literally int 99 store karta hai.

Verify: stored value unchanged hai → 99 print hota hai. ✅

Worked example Ex 7 — Cell G: real-world word problem

Problem: Ek vending machine states ke through cycle karti hai: waiting, coin inserted, dispensing, out-of-stock. Aapko (a) states model karni hain aur (b) ek int timeInState[...] array size karni hai jo log kare ki usne har state mein kitne seconds bitaye. Enum use karo. Array size do.

Forecast: kaun sa enum layout aapko array size for free deta hai?

States ko trailing sentinel wale enum se model karo:
```
enum State { WAITING, COIN_IN, DISPENSING, OUT_OF_STOCK, STATE_COUNT };
int timeInState[STATE_COUNT];
```
Yeh step kyun? Names magic numbers se behtar hote hain (parent note) aur sentinel log ko auto-size karta hai — states par switch statement bhi readable rehta hai.
Values: WAITING=0, COIN_IN=1, DISPENSING=2, OUT_OF_STOCK=3, isliye STATE_COUNT = 3 + 1 = 4. Yeh step kyun? Default +1 counting; sentinel = 4 real states ki count.
timeInState mein isliye 4 elements hain, indices 0–3, ek har real state ke liye. Yeh step kyun? Ek slot per state, enum se index karke — timeInState[DISPENSING] English ki tarah padhta hai.

Verify: 4 real states → STATE_COUNT = 4 → array length 4. ✅

Worked example Ex 8 — Cell H: exam twist (mixed

= aur gaps)

enum Q { A, B = 4, C, D = B, E, F = -1, G };

Forecast: trace karne se pehle A,B,C,D,E,F,G likh lo.

A = 0 (pehla, plain). Yeh step kyun? Pehla un-initialised enumerator 0 hota hai.
B = 4 (explicit). Anchor 4.
C = 4 + 1 = 5 (plain). Yeh step kyun? B se +1.
D = B. B ek compile-time constant hai jo 4 ke barabar hai, isliye D = 4. Yeh step kyun? Ek enumerator ka initialiser doosre enumerator ki value ho sakta hai — yeh ek constant expression hai. Ab D, B ki value duplicate karta hai (legal!).
E = D + 1 = 5 (plain). Yeh step kyun? Pichle enumerator ki value se +1 (D = 4 hai), jo 5 deta hai — ab E, C ko duplicate karta hai!
F = -1 (explicit). Anchor $- 1$ .
G = -1 + 1 = 0 (plain) — A ko duplicate karta hai. Yeh step kyun? F se +1, 0 tak upar chalte hue.

Verify: A=0, B=4, C=5, D=4, E=5, F=-1, G=0. Teen "accidental" duplicate pairs (B&D, C&E, A&G) sab legal hain. ✅

Active recall

Recall Har cell ke liye ek line — matrix yaad se cover karo

Cell A: enum {X,Y,Z}; mein Z ki value? → 2
Cell B: enum {P=200,Q,R}; mein R ki value? → 202
Cell C: enum {N=-3,M}; mein M ki value? → -2
Cell D: kya do enumerators dono 5 ke barabar ho sakte hain? → Haan
Cell E: enum{A,B,C,COUNT}; mein COUNT ki value? → 3
Cell F: kya enum Color c = 99; compile hota hai? → Haan, 99 print karta hai
Cell H: enum{J,K=4,L,M=J}; mein M ki value? → 0 (J=0)

Trace-the-chain drills:

enum {A, B=4, C}; mein C ki value

enum {N=-3, M}; mein M ki value

-2 (counting negatives se guzarti hai)

Kya enum X { A=5, B=5 }; legal hai?

Haan — sirf names unique hone chahiye, values repeat ho sakti hain

enum{RED,GREEN,BLUE,COUNT}; mein COUNT kya hai?

3 (automatically real items ki count ke barabar)

Kya enum Color c = 99; C mein compile hota hai?

Haan — enums int se freely convert hote hain, koi clamping nahi

Connections

Enumerations — parent note; yeh page uska worked-examples annex hai.
Integer Types in C — kyun sizeof(int) ne Ex 5 mein array-byte counts diye.
switch statement — Ex 7 ki state machine enum par switch hoti hai.
Arrays in C — sentinel-sizing trick (Ex 5, Ex 7).
struct in C — ek enum "tag" ko struct ke saath pair karo tagged unions ke liye.
typedef — typedef enum {...} State; Ex 7 mein enum keyword hata deta hai.

Worked examples — Enumerations