Mid-level 4 min · March 06, 2026

switch Fall-Through in C — The Bug That Doubles Output

A missing break caused duplicate charges with zero error logs.

N
Naren · Founder
Plain-English first. Then code. Then the interview question.
About
 ● Production Incident 🔎 Debug Guide
Quick Answer
  • Control flow is the decision-making engine of a C program — it determines which code runs, how many times, and when to stop
  • if/else evaluates conditions top-to-bottom, executing the first true branch and skipping the rest
  • for loops handle known iteration counts; while loops handle unknown counts; do-while guarantees at least one execution
  • switch selects among exact integer matches using a jump table — faster than chained comparisons for 5+ options
  • Missing break in switch causes silent fall-through: the #1 source of unexplained multi-branch execution in production C code
  • Forgetting loop variable updates causes infinite loops — the CPU pegs at 100% and the process gets OOM-killed
Plain-English First

Imagine you're a traffic cop standing at a busy intersection. You don't just wave every car through blindly — you check conditions ('Is the light red? Is an ambulance coming?') and then decide what action to take. Control flow in C is exactly that traffic cop: it lets your program check conditions and decide which road to go down, how many times to loop around the block, or when to stop entirely. Without it, every C program would just run the same instructions in a straight line, top to bottom, every single time — useless for anything real.

Every useful program needs to make decisions. That decision-making power is called control flow, and it's the difference between a program that does one fixed thing and a program that reacts intelligently to the world around it.

Before structured control flow existed, coders used raw jump instructions — a chaotic mess known as spaghetti code. C gave programmers clean, readable structures: if/else for decisions, for and while loops for repetition, and switch for picking from a menu of options. These structures impose order so both humans and compilers can follow what a program is doing.

By the end of this article you'll be able to write a C program that makes real decisions, repeats actions a controlled number of times, and handles multiple choices cleanly. You'll also know the two most common mistakes beginners make with control flow — the ones that cause silent bugs that are a nightmare to track down.

Making Decisions with if, else if, and else

The if statement is the foundation of every decision your program makes. Think of it as a bouncer at a club door: 'IF you're on the list, you get in. Otherwise, you don't.' The bouncer evaluates one condition — true or false — and acts accordingly.

In C, a condition is any expression that evaluates to zero (false) or non-zero (true). That's it. There's no separate boolean type in classic C — zero means false, everything else means true.

You chain decisions together with else if when there are multiple possibilities. Think of it like a thermostat: if the temperature is above 30°C, turn on the AC; else if it's below 15°C, turn on the heat; otherwise, do nothing. Each condition is checked in order from top to bottom, and the moment one matches, C executes that block and skips the rest.

Always use curly braces {} around your block, even for single-line bodies. It costs nothing and prevents a classic category of bugs we'll cover in the mistakes section.

temperature_check.cCPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>

int main(void) {
    int temperature = 28; /* degrees Celsius — change this to test different branches */

    if (temperature > 30) {
        /* This block only runs when temperature is strictly greater than 30 */
        printf("It's scorching! Turn the air conditioning on.\n");
    } else if (temperature >= 20) {
        /* Runs when temperature is between 20 and 30 (inclusive of 20) */
        printf("It's comfortable. No action needed.\n");
    } else if (temperature >= 10) {
        /* Runs when temperature is between 10 and 19 */
        printf("A bit chilly. Maybe grab a jacket.\n");
    } else {
        /* Catches everything below 10 — the 'default' safety net */
        printf("It's freezing! Turn the heating on.\n");
    }

    return 0; /* 0 tells the operating system the program finished successfully */
}
Output
It's comfortable. No action needed.
Pro Tip: Order Your Conditions from Most Specific to Least
C evaluates else-if chains top-to-bottom and stops at the first true match. If you put a broad condition (like temperature > 0) before a narrow one (like temperature > 30), the broad one swallows everything and your specific branch never runs. Always go from most restrictive to least restrictive.
Production Insight
In production, wrong condition ordering causes silent incorrect behavior — no crash, just wrong output. A rate limiter checking 'requests > 0' before 'requests > 1000' will never trigger the throttle.
Always order from most specific to most general. Test boundary values explicitly: the exact threshold, one above, one below.
Key Takeaway
C has no boolean type — zero is false, everything else is true.
Condition ordering matters: broad conditions placed first swallow narrow ones silently.
The punchline: always write {} braces, even for single-line bodies — it prevents the dangling-else bug that compiles cleanly but runs wrong.
Choosing the Right Conditional Structure
IfSingle true/false check
UseUse a simple if block
IfTwo mutually exclusive paths
UseUse if / else
IfThree or more distinct ranges or values on the same variable
UseUse if / else if / else chain, ordered most-specific first
IfFive or more exact integer matches on one variable
UseConsider switch for readability and potential jump-table optimization

Repeating Actions with for, while, and do-while Loops

Loops solve one of the most tedious problems in programming: doing something many times without copy-pasting code. Imagine counting to a million by hand — loops let you write the instruction once and let the computer do the repetition.

The for loop is your go-to when you know exactly how many times you need to repeat. It packages the counter setup, the condition, and the counter update all on one line — making it easy to read at a glance. Use it when you have a definite number of iterations.

The while loop is for when you don't know in advance how many times you'll loop — you keep going as long as a condition holds true. Think of it like eating chips from a bag: you keep reaching in while there are chips left. The condition is checked before each iteration, so if it starts false, the body never runs at all.

The do-while loop is the rarer sibling. It runs the body first, then checks the condition. This guarantees the body executes at least once — perfect for menus where you always need to show the prompt before you can check the user's input.

loops_demo.cCPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <stdio.h>

int main(void) {

    /* ── FOR LOOP ──────────────────────────────────────────────
       We know exactly how many students we have (5),
       so a for loop is the cleanest choice here.
       Breakdown of: for (initializer; condition; update)
         - int student = 1      → start counting at student 1
         - student <= 5         → keep going while we haven't exceeded 5
         - student++            → after each loop body, add 1 to student
    ────────────────────────────────────────────────────────── */
    printf("--- Roll Call (for loop) ---\n");
    for (int student = 1; student <= 5; student++) {
        printf("Calling student number %d\n", student);
    }

    /* ── WHILE LOOP ────────────────────────────────────────────
       We don't know how many attempts the user will need,
       so while is more natural. Here we simulate a countdown
       where fuel_level drives when we stop.
    ────────────────────────────────────────────────────────── */
    printf("\n--- Rocket Fuel Countdown (while loop) ---\n");
    int fuel_level = 5;
    while (fuel_level > 0) {
        printf("Fuel level: %d — burning...\n", fuel_level);
        fuel_level--; /* subtract 1 from fuel each iteration */
    }
    printf("Fuel exhausted. Engine off.\n");

    /* ── DO-WHILE LOOP ─────────────────────────────────────────
       The menu always needs to display at least once before
       we can check what the user chose. do-while guarantees
       the body runs before the condition is ever evaluated.
    ────────────────────────────────────────────────────────── */
    printf("\n--- Vending Machine Menu (do-while loop) ---\n");
    int user_choice;
    do {
        printf("Press 1 for Coffee, 2 for Tea, 0 to Exit: ");
        /* Hardcoded for demo — in a real program this would be scanf() */
        user_choice = 1;
        printf("%d\n", user_choice); /* echo the simulated input */

        if (user_choice == 1) {
            printf("Dispensing coffee. Enjoy!\n");
        } else if (user_choice == 2) {
            printf("Dispensing tea. Enjoy!\n");
        }
    } while (user_choice != 0); /* keep looping until user chooses Exit */
    /* NOTE: Because user_choice is hardcoded to 1 above, this loops once
       and then re-evaluates. In a real program, scanf would update it. */

    return 0;
}
Output
--- Roll Call (for loop) ---
Calling student number 1
Calling student number 2
Calling student number 3
Calling student number 4
Calling student number 5
--- Rocket Fuel Countdown (while loop) ---
Fuel level: 5 — burning...
Fuel level: 4 — burning...
Fuel level: 3 — burning...
Fuel level: 2 — burning...
Fuel level: 1 — burning...
Fuel exhausted. Engine off.
--- Vending Machine Menu (do-while loop) ---
Press 1 for Coffee, 2 for Tea, 0 to Exit: 1
Dispensing coffee. Enjoy!
Loop Selection Mental Model
  • for — you know the count before you start (iterating arrays, fixed retries)
  • while — you check before acting and may never enter the body (stream reading, polling)
  • do-while — you act first, then decide whether to continue (menus, input validation)
  • If the body must run at least once, do-while is the only correct choice — while and for can skip entirely
Production Insight
Infinite loops in production cause OOM kills or 100% CPU alerts — the process hangs and stops serving traffic.
The usual culprit: a while loop whose condition variable is never updated inside the body.
Always verify your loop variable changes each iteration. Use a timeout or iteration cap as a safety net in production code.
Key Takeaway
for is for known counts — all logic in one line, minimal infinite-loop risk.
while and do-while require manual counter management — forgetting the update causes infinite loops.
Punchline: do-while is the only loop guaranteed to run at least once — if your body must execute before checking a condition, it's the only correct choice.
Choosing the Right Loop Type
IfExact iteration count known upfront
UseUse for — counter is explicit in the header, lowest infinite-loop risk
IfLoop until an external condition changes, count unknown
UseUse while — check condition before each iteration
IfBody must execute at least once (menus, input prompts)
UseUse do-while — guarantees one execution before any condition check
IfProcessing a data stream with no predetermined end
UseUse while with a sentinel value or EOF check

Choosing Between Many Options with switch

Once you have more than three or four else-if branches all checking the same variable, your code starts to look like a wall of text. The switch statement was invented to fix that. Think of it like a hotel receptionist's key cabinet: you give them your room number, they go directly to that slot and hand you the key — they don't check every slot from 1 to 500.

switch works on integer values (including char, which is just a small integer). You provide the variable to check, then list case labels — each one like a named slot in that key cabinet. C jumps directly to the matching case and starts executing from there.

The critical detail beginners miss: C doesn't automatically stop at the end of a case. It falls through to the next case unless you explicitly write break. This behavior is sometimes useful (you'll see it in the code below where two cases share one action), but usually it's a bug. Always write break at the end of every case unless you've deliberately chosen to fall through, and comment that intention clearly.

The default case is your safety net — it catches any value that didn't match a case label. Always include it.

day_of_week.cCPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <stdio.h>

int main(void) {
    int day_number = 3; /* 1 = Monday, 2 = Tuesday, ... 7 = Sunday */

    printf("Day %d is: ", day_number);

    switch (day_number) {
        case 1:
            printf("Monday\n");
            break; /* break jumps execution to after the closing } of switch */

        case 2:
            printf("Tuesday\n");
            break;

        case 3:
            printf("Wednesday\n");
            break;

        case 4:
            printf("Thursday\n");
            break;

        case 5:
            printf("Friday\n");
            break;

        case 6:  /* Intentional fall-through — Saturday AND Sunday share the same message */
        case 7:  /* No break on case 6, so C slides down into case 7's body */
            printf("Weekend! No work today.\n");
            break; /* break HERE stops us falling into default */

        default:
            /* Catches any value outside 1-7 — always include this guard */
            printf("Invalid day number. Please use 1 to 7.\n");
            break;
    }

    return 0;
}
Output
Day 3 is: Wednesday
Interview Gold: Why Does switch Fall Through by Default?
Interviewers love this question. The fall-through behavior is inherited from C's assembly roots — a jump table where after executing a case, the CPU would naturally continue to the next instruction. The designers kept it because intentional fall-through (like grouping Saturday and Sunday) is genuinely useful. The cost is that forgetting break is one of the most common bugs in C code.
Production Insight
switch with many cases compiles to a jump table — O(1) dispatch vs O(n) for chained else-if.
This matters in hot paths: a packet dispatcher handling 50 protocol types runs measurably faster with switch.
But switch only works on integer types. For floating-point ranges or string matching, you need if-else or a lookup table.
Key Takeaway
switch compiles to a jump table for O(1) dispatch — faster than sequential else-if for many branches.
Fall-through is the default: without break, execution slides into the next case even if the label doesn't match.
Punchline: always add break unless fall-through is intentional, and comment it — missing break is the single sneakiest silent bug in C.
Choosing Between switch and if-else
IfComparing one integer variable against 4+ exact values
UseUse switch — cleaner, potential jump-table optimization
IfConditions involve ranges, floating point, or compound logic
UseUse if-else — switch cannot express range checks
IfMultiple cases should execute the same code
UseUse switch with intentional fall-through — group cases without break between them
IfFewer than 3 branches on different variables
UseUse if-else — switch adds unnecessary structure for simple decisions

Controlling Loops Precisely with break and continue

Sometimes you're mid-loop and you need to either bail out entirely or skip the rest of the current iteration and jump to the next one. C gives you two keywords for this: break and continue.

You already saw break in switch. In a loop, break does the same thing — it exits the loop immediately and picks up execution on the line after the loop's closing brace. Think of it as a fire alarm: no matter what you're doing, you drop everything and leave the building right now.

continue is subtler. It doesn't exit the loop — it skips the rest of the current iteration and goes straight to the next one. Think of a quality inspector on an assembly line: if a product is already marked as defective, they skip all the remaining checks for that item and move to the next product. The line doesn't stop — one item just gets skipped.

Use break when a condition means there's no point continuing the loop at all. Use continue when you just want to skip processing for this particular iteration but the loop itself should keep going.

break_and_continue.cCPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <stdio.h>

int main(void) {

    /* ── BREAK EXAMPLE ────────────────────────────────────────
       We're scanning a list of exam scores to find the first
       student who failed (scored below 50). Once we find one,
       there's no need to keep scanning — we break out.
    ────────────────────────────────────────────────────────── */
    int exam_scores[] = {78, 91, 65, 43, 88, 55}; /* array of 6 scores */
    int total_students = 6;

    printf("--- Scanning for first failing score (break demo) ---\n");
    for (int index = 0; index < total_students; index++) {
        if (exam_scores[index] < 50) {
            /* Found a failing score — report it and stop searching */
            printf("First fail found at index %d: score %d\n", index, exam_scores[index]);
            break; /* exit the for loop immediately */
        }
        printf("Score %d passed.\n", exam_scores[index]);
    }

    /* ── CONTINUE EXAMPLE ─────────────────────────────────────
       We want to print only the ODD numbers from 1 to 10.
       When we hit an even number, we skip (continue) to the
       next iteration rather than printing it.
    ────────────────────────────────────────────────────────── */
    printf("\n--- Printing only odd numbers 1-10 (continue demo) ---\n");
    for (int number = 1; number <= 10; number++) {
        if (number % 2 == 0) {
            /* % is the modulus operator — it gives the remainder.
               If remainder after dividing by 2 is 0, the number is even. */
            continue; /* skip the printf below and go to next iteration */
        }
        /* This line only executes for odd numbers */
        printf("%d is odd\n", number);
    }

    return 0;
}
Output
--- Scanning for first failing score (break demo) ---
Score 78 passed.
Score 91 passed.
Score 65 passed.
First fail found at index 3: score 43
--- Printing only odd numbers 1-10 (continue demo) ---
1 is odd
3 is odd
5 is odd
7 is odd
9 is odd
Pro Tip: break Only Exits ONE Level
If you have a loop nested inside another loop, break only exits the innermost loop — not both. This surprises a lot of beginners. If you need to exit multiple nested loops at once, use a flag variable (a boolean set to true when you want to stop) and check it in each outer loop's condition, or restructure the code into a function and use return.
Production Insight
break only exits the innermost loop — in nested loops, this is a frequent source of logic errors.
If you need to exit multiple levels, use a flag variable checked in each outer loop condition.
In production, this manifests as partial processing: a search stops too early or a cleanup loop skips outer iterations.
Key Takeaway
break exits the entire loop immediately — think fire alarm, evacuate now.
continue skips only the current iteration — think quality inspector, skip this defective item but keep the line running.
Punchline: break only exits one nesting level — for nested loops, use a flag variable or restructure into a function.
Choosing Between break and continue
IfFound what you need — no point continuing the loop
UseUse break — exits immediately, skips remaining iterations
IfCurrent item is invalid but the loop should keep processing
UseUse continue — skips to the next iteration
IfNeed to exit nested loops at once
UseUse a flag variable checked in outer loop conditions, or restructure into a function with return
IfNeed to exit a loop from deep inside conditional logic
Usebreak works from any depth inside the loop body — it always exits the enclosing loop
● Production incidentPOST-MORTEMseverity: high

Missing break in switch causes duplicate charges in payment processing

Symptom
Customer accounts showed duplicate charges. Reconciliation totals were exactly double the expected amount. No crash, no error logs — just silently wrong financial data.
Assumption
The team assumed a race condition or duplicate message delivery from the message queue.
Root cause
A developer added a new case for 'partial_refund' status but forgot the break statement. When a transaction had partial_refund status, C fell through into the full_refund case and executed both refund paths. The data was written to the ledger twice.
Fix
Added break to the partial_refund case. Added a compiler warning flag (-Wimplicit-fallthrough) and a mandatory code review checklist item for every switch modification.
Key lesson
  • Always add break to every switch case unless fall-through is intentional
  • Comment intentional fall-through explicitly so reviewers don't 'fix' it
  • Enable -Wimplicit-fallthrough in your compiler flags — it catches this at compile time
  • Financial code paths must have integration tests that verify exact output amounts
Production debug guideCommon control flow failures and how to diagnose them5 entries
Symptom · 01
Program hangs at 100% CPU, never returns
Fix
Attach gdb, check the call stack — you're almost certainly in an infinite loop. Look for a loop variable that never changes.
Symptom · 02
Wrong branch executes — e.g., both 'if' and 'else' blocks appear to run
Fix
Check for a missing break in switch. Add temporary printf in each case to trace execution order.
Symptom · 03
Loop runs zero times when you expected at least one iteration
Fix
You're using while or for (pre-condition). If the body must run first, use do-while instead.
Symptom · 04
Condition always evaluates true regardless of input
Fix
Check for assignment (=) instead of comparison (==) in the condition. Compile with -Wparentheses to get a warning.
Symptom · 05
Nested loop break only exits the inner loop
Fix
break only exits one level. Use a flag variable checked in the outer loop condition, or restructure into a function and use return.
Loop Type Comparison
Featurefor loopwhile loopdo-while loop
Condition checkedBefore each iterationBefore each iterationAfter each iteration
Guaranteed minimum runs0 — skips if condition starts false0 — skips if condition starts false1 — always runs body once
Best used whenYou know the exact iteration countYou loop until an unknown conditionYou need at least one execution (menus, input validation)
Counter managementBuilt into the loop headerManual — you manage it yourselfManual — you manage it yourself
Readability for fixed countsExcellent — all in one lineOkay — counter scattered in codeOkay — counter scattered in code
Risk of infinite loopLow — counter is explicitMedium — easy to forget the updateMedium — easy to forget the update

Key takeaways

1
In C, any non-zero value is true and zero is false
there's no separate boolean type in classic C, so conditions like 'if (count)' mean 'if count is not zero'.
2
Use for when you know the iteration count, while when you loop until a condition changes, and do-while when the body must execute at least once before any condition is checked.
3
Every switch case needs a break unless fall-through is intentional
missing break causes the next case's code to execute even when its label doesn't match, one of the sneakiest silent bugs in C.
4
break exits the entire loop immediately; continue skips only the current iteration and lets the loop keep running
confusing these two causes logic bugs that are hard to spot by reading code quickly.

Common mistakes to avoid

3 patterns
×

Semicolon after if or for

Symptom
The block in {} runs unconditionally every time — the if or for has an empty statement as its body and the block below executes regardless of the condition.
Fix
Never put a semicolon directly after the closing parenthesis of if, for, or while. If your IDE warns about an empty statement, treat it as a bug.
×

Forgetting break in switch

Symptom
C falls through to the next case and executes it too, even if its label doesn't match. Code for case 3 runs whenever case 2 matches if case 2 has no break.
Fix
Add break as the last line of every case. If you deliberately fall through, add a comment like / intentional fall-through / so future readers know it's on purpose.
×

Using = instead of == in a condition

Symptom
Writing 'if (score = 50)' assigns 50 to score and evaluates to 50 (non-zero), so the condition is always true regardless of score's original value. This compiles without error and creates a silent logic bug.
Fix
Use == for comparison. Many developers write constants on the left ('if (50 == score)') — the compiler catches '50 = score' as an error since you can't assign to a literal.
INTERVIEW PREP · PRACTICE MODE

Interview Questions on This Topic

Q01JUNIOR
What is the difference between a while loop and a do-while loop in C, an...
Q02SENIOR
Why does switch statement fall-through happen in C, and how do you handl...
Q03SENIOR
What happens if you write 'if (a = b)' instead of 'if (a == b)' in C — w...
Q01 of 03JUNIOR

What is the difference between a while loop and a do-while loop in C, and can you give a real scenario where you'd choose do-while over while?

ANSWER
A while loop checks its condition before executing the body — if the condition is false initially, the body never runs. A do-while loop executes the body first, then checks the condition — guaranteeing at least one execution. Use do-while for menus and input validation prompts where you must display the prompt before checking the user's response.
FAQ · 3 QUESTIONS

Frequently Asked Questions

01
What is control flow in C programming?
02
When should I use a switch statement instead of if-else in C?
03
Can a for loop in C run zero times?
🔥

That's C Basics. Mark it forged?

4 min read · try the examples if you haven't

Previous
Operators in C
4 / 17 · C Basics
Next
Functions in C