Enumerations: Worked examples — Coding deep dive

This page is a shooting range: we list every kind of enum situation C can throw at you, then knock each one down with a fully worked example. If you have not yet seen how enums count, read the parent first: Enumerations.

Before we start, one promise from that parent note we will lean on constantly:

Everything below is this rule applied to trickier and trickier inputs.

The scenario matrix

Think of every enum you will ever meet as landing in one of these cells. Our job is to hit all of them.

#	Case class	What makes it tricky	Hit by
A	Pure defaults	plain 0,1,2,… counting	Ex 1
B	Explicit start, then resume	+1 rule continues from any number	Ex 2
C	Negative explicit value	counting still means +1, from below zero	Ex 3
D	Duplicate values	two names, one integer — legal	Ex 4
E	Zero / empty-ish & sentinel	trailing `COUNT` sizing an array	Ex 5
F	Out-of-range assignment	`enum c = 99;` — the "no type safety" edge	Ex 6
G	Real-world word problem	choosing enum vs magic numbers	Ex 7
H	Exam twist — mixed `=` and gaps	trace the whole chain by hand	Ex 8

Cells A–H below are each labelled. Together they cover defaults, explicit, resumed, negative, duplicate, zero/sentinel, degenerate/out-of-range, real-world, and exam-style — no scenario left uncovered.

The figure below shows the mental model we use everywhere: named sticky-notes on a number line.

The worked examples

Worked example Ex 1 — Cell A: pure defaults

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

Forecast: guess the two printed numbers before reading on.

MERCURY is first with no =, so it is $0$ . Why this step? The rule says the first un-initialised enumerator is $0$ .
VENUS = 0 + 1 = 1, EARTH = 1 + 1 = 2, MARS = 2 + 1 = 3. Why this step? Each later plain enumerator is previous $+ 1$ .
printf("%d %d", EARTH, MARS) prints the stored ints, not names. Why this step? An enum constant is an int at runtime; C has no name table.

Verify: count fingers 0,1,2,3 → EARTH = 2, MARS = 3. Output: 2 3. ✅

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

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

Forecast: three numbers — jot them down.

OK = 200 (explicit). "Previous value" is now $200$ . Why this step? An explicit = sets the anchor the +1 rule counts from.
CREATED = 200 + 1 = 201, ACCEPTED = 201 + 1 = 202. Why this step? No =, so plain +1 continues.
MOVED = 301 (explicit) resets the anchor; NOTFOUND = 301 + 1 = 302. Why this step? The +1 rule never stops — it just resumes from the newest explicit value.

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: does +1 still work when we start below zero? Guess the three values.

FREEZING = -3 (explicit, negative). Anchor is $- 3$ . Why this step? Explicit values may be any constant integer, including negatives.
T_A = -3 + 1 = -2, T_B = -2 + 1 = -1, T_C = -1 + 1 = 0. Why this step? "+1 over previous" is arithmetic on the number line — it walks upward through negatives, through zero, without any special case.

Verify: on the number line $- 3 \to - 2 \to - 1 \to 0$ . Output: -2 -1 0. ✅ The count passes through 0 — nothing magic happens there.

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

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

Forecast: will WARN == FATAL compile? What does it print?

INFO = 0, WARN = 5 (explicit). Anchor $5$ . Why this step? Standard explicit assignment.
ERR = 5 + 1 = 6. Why this step? Plain +1 after WARN.
FATAL = 5 (explicit) — same integer as WARN. This is allowed. Why this step? The rule "must be unique" applies to names, not values. Two names may share one integer.
WARN == FATAL compares $5 == 5$ → true → prints 1. Why this step? They are just ints; equal ints compare equal.

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

Worked example Ex 5 — Cell E: zero-based sentinel sizing an array

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

Forecast: how many elements does steps have?

SUN = 0 … SAT = 6 by the +1 rule (7 real days, indices 0–6). Why this step? Standard default counting; the last real item lands at $6$ .
DAY_COUNT = 6 + 1 = 7. It is not a real day — it is a sentinel that equals "how many came before it". Why this step? Placed last with no =, a sentinel automatically equals the count of preceding enumerators. Add a day → count updates for free (see Arrays in C).
int steps[DAY_COUNT] is int steps[7]. The element count via sizeof is $7 \times 4/4 = 7$ (assuming 4-byte int — see Integer Types in C). Why this step? sizeof(array)/sizeof(element) is the classic array-length idiom.

Verify: DAY_COUNT = 7, and the array holds 7 ints. Output: 7 then 7. ✅

The sentinel trick is worth a picture — the last note is a tally, not a day:

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

enum Color { RED, GREEN, BLUE };   // 0,1,2
enum Color c = 99;                 // does this even compile?
printf("%d\n", c);

Forecast: compile error, warning, or silent success?

RED=0, GREEN=1, BLUE=2 — the valid "colours". Why this step? Default counting.
enum Color c = 99; compiles even though 99 is no colour. Why this step? In C an enum is freely convertible to/from int — there is almost no type safety here. C trusts you.
printf("%d", c) prints 99. There is no clamping, no wrap, no error. Why this step? The variable literally stores the int 99.

Verify: stored value is unchanged → prints 99. ✅

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

Problem: A vending machine cycles through states: waiting, coin inserted, dispensing, out-of-stock. You must (a) model the states and (b) size a int timeInState[...] array to log how many seconds it spent in each state. Use an enum. Give the array size.

Forecast: which enum layout gives you the array size for free?

Model states as an enum with a trailing sentinel:
```
enum State { WAITING, COIN_IN, DISPENSING, OUT_OF_STOCK, STATE_COUNT };
int timeInState[STATE_COUNT];
```
Why this step? Names beat magic numbers (parent note) and the sentinel auto-sizes the log — the switch statement over states also stays readable.
Values: WAITING=0, COIN_IN=1, DISPENSING=2, OUT_OF_STOCK=3, so STATE_COUNT = 3 + 1 = 4. Why this step? Default +1 counting; sentinel = count of the 4 real states.
timeInState therefore has 4 elements, indices 0–3, one per real state. Why this step? One slot per state, indexed by the enum itself — timeInState[DISPENSING] reads like English.

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

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

= and gaps)

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

Forecast: write down A,B,C,D,E,F,G before tracing.

A = 0 (first, plain). Why this step? First un-initialised enumerator is 0.
B = 4 (explicit). Anchor 4.
C = 4 + 1 = 5 (plain). Why this step? +1 from B.
D = B. B is a compile-time constant equal to 4, so D = 4. Why this step? An enumerator's initialiser may be another enumerator's value — it is a constant expression. Now D duplicates B's value (legal!).
E = D + 1 = 5 (plain). Why this step? +1 from the previous enumerator's value (which is D = 4), giving 5 — now E duplicates C!
F = -1 (explicit). Anchor $- 1$ .
G = -1 + 1 = 0 (plain) — duplicates A. Why this step? +1 from F, walking up to 0.

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

Active recall

Recall One line per cell — cover the matrix from memory

Cell A: enum {X,Y,Z}; value of Z? → 2
Cell B: enum {P=200,Q,R}; value of R? → 202
Cell C: enum {N=-3,M}; value of M? → -2
Cell D: can two enumerators both equal 5? → Yes
Cell E: enum{A,B,C,COUNT}; value of COUNT? → 3
Cell F: does enum Color c = 99; compile? → Yes, prints 99
Cell H: enum{J,K=4,L,M=J}; value of M? → 0 (J=0)

Trace-the-chain drills:

Value of C in enum {A, B=4, C};

Value of M in enum {N=-3, M};

-2 (counting passes through negatives)

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

Yes — only names must be unique, values may repeat

In enum{RED,GREEN,BLUE,COUNT}; what is COUNT?

3 (auto-equals the number of real items)

Does enum Color c = 99; compile in C?

Yes — enums freely convert to/from int, no clamping

Connections

Enumerations — the parent; this page is its worked-examples annex.
Integer Types in C — why sizeof(int) gave us array-byte counts in Ex 5.
switch statement — the state machine of Ex 7 is switched on the enum.
Arrays in C — the sentinel-sizing trick (Ex 5, Ex 7).
struct in C — pair an enum "tag" with a struct for tagged unions.
typedef — typedef enum {...} State; drops the enum keyword in Ex 7.

Worked examples — Enumerations