Control Flow in C: Statements for Decisions and Repetition

The Three Ways Programs Flow

Every program ever written uses some combination of three structures:

1. Sequential — statements run top to bottom, in order. Everything we've done so far.

2. Selection (decisions) — the program chooses between paths based on a condition. Like a fork in the road.

3. Repetition (loops) — the program runs the same code multiple times. Like running laps around a track.

That's genuinely it. Every app, game, and operating system you've ever used is built from these three structures combined in clever ways. Learn to see them, and you can read anyone's code.

Part 1: Making Decisions

The if Statement — The Simplest Decision

if runs a block of code only when its condition is true:

#include <stdio.h>
int main() {
    int age;
    printf("Enter your age: ");
    scanf("%d", &age);
    if (age >= 18) {
        printf("You can vote!\n");
    }
    printf("Program finished.\n");
    return 0;
}

Two possible runs:

Enter your age: 21You can vote!Program finished.

Enter your age: 15Program finished.

Notice how "You can vote!" only appears when the condition passes — otherwise the program skips that block entirely. The condition age >= 18 is either true (any non-zero value in C) or false (zero). That's the entire logic system in one sentence: zero is false, everything else is true.

(Suggested image: if-statement flowchart — condition diamond with "true" arrow going into the block and "false" arrow skipping around it)

if-else — Choosing Between Two Paths

When you need to handle both outcomes:

if (age >= 18) {
    printf("You can vote!\n");
} else {
    printf("Too young to vote. Wait %d more years.\n", 18 - age);
}

Exactly one of the two blocks always runs — never both, never neither.

else if — Handling Multiple Conditions

For more than two paths, chain them:

int marks = 85;
if (marks >= 90) {
    puts("Grade: A");
} else if (marks >= 75) {
    puts("Grade: B");
} else if (marks >= 60) {
    puts("Grade: C");
} else if (marks >= 40) {
    puts("Grade: D");
} else {
    puts("Grade: F");
}

Output: Grade: B

C checks conditions top to bottom and runs the first one that's true — then skips everything below it. Order matters: if you put marks >= 40 first, an 85 would match it immediately and never reach the A/B checks. Always arrange conditions from most specific to most general.

switch — The Many-Way Branch

When you're comparing one variable against several fixed values, switch reads cleaner than a long else if chain:

int choice = 2;
switch (choice) {
    case 1: puts("You chose: New Game");
    break;
    case 2: puts("You chose: Load Game");
    break;
    case 3: puts("You chose: Settings");
    break;
    default: puts("Invalid choice!");
}

Output: You chose: Load Game

Two things to know immediately:

• break is not optional decoration. Without it, execution "falls through" into the next case. Forget it, and choosing option 1 prints all four messages. It's the single most common switch bug.
• default catches anything that matches no case — like the else of a switch.

switch works with integers and characters. It does not work with strings or floating-point numbers — that's a limitation that surprises people coming from other languages.

Part 2: Repetition — The Three Loops

The for Loop — When You Know How Many Times

for packs everything into one line: starting point, condition, and step.

for (int i = 1;
i <= 5;
i++) {
    printf("Lap %d complete!\n", i);
}

Output:

Lap 1 complete!Lap 2 complete!Lap 3 complete!Lap 4 complete!Lap 5 complete!

Reading the header like a sentence: "Start i at 1; keep going while i is at most 5; add 1 after each pass."

Reach for for when: you know the count in advance — processing arrays, printing tables, repeating something exactly N times.

The while Loop — When You Don't Know How Many Times

while checks a condition and keeps looping as long as it's true:

int battery = 100;
while (battery > 0) {
    printf("Battery: %d%%\n", battery);
    battery -= 25;
}
puts("Battery dead!");

Output:

Battery: 100%Battery: 75%Battery: 50%Battery: 25%Battery dead!

The condition is checked before each pass — which means if it's false from the start, the loop body never runs at all. That's a feature: while (scanf("%d", &x) == 1) loops only while valid input keeps coming.

Reach for while when: the loop depends on a condition, not a count — reading until EOF, waiting for valid input, repeating until something changes.

The do-while Loop — Run First, Check Later

The odd sibling: do-while checks its condition after the body, guaranteeing at least one execution:

int pin;
do {
    printf("Enter 4-digit PIN: ");
    scanf("%d", &pin);
} while (pin != 4321);
puts("Access granted!");

The prompt must appear at least once before we can check the PIN — which is exactly what do-while expresses. Menus, input validation, "play again?" prompts: classic do-while territory.

(Suggested image: a three-way flowchart comparison — for/while checking the condition BEFORE the body, do-while checking AFTER. Visual learners will thank you.)

Choosing the Right Loop: Quick Guide

Honest truth? Any loop can imitate any other with enough effort. These guidelines aren't laws — they're about which choice makes your intent clearest to the next person reading the code (often future you).

Part 3: Jump Statements — The Emergency Exits

break — Exit Immediately

break punches straight out of the nearest loop (or switch):

for (int i = 1;
i <= 100;
i++) {
    if (i == 6) {
        break;
        // stop entirely at 6
    }
    printf("%d ", i);
}
// Output: 1 2 3 4 5

continue — Skip to the Next Round

continue skips the rest of this pass and jumps to the next iteration:

for (int i = 1;
i <= 10;
i++) {
    if (i % 2 == 0) {
        continue;
        // skip even numbers
    }
    printf("%d ", i);
}
// Output: 1 3 5 7 9

The difference in one line: break leaves the loop; continue skips ahead within it.

goto — The One Everyone Warns You About

Yes, C has goto. Yes, it jumps anywhere in the function. And yes, you should avoid it in normal code — it turns programs into "spaghetti" that nobody can follow. There's exactly one place experienced programmers still accept it: jumping to cleanup code at the end of a function in low-level systems code. Until you write kernels or drivers, file goto under "good to know it exists."

The Classic Beginner Traps

1. The accidental semicolon — if (age >= 18); ends the statement immediately; the block below runs always. Same with while (x > 0); — which creates an infinite loop doing nothing.
2. = instead of == — if (x = 5) assigns 5 (and is always true); if (x == 5) compares. Probably the most famous C bug of all time.
3. Missing break in switch — cases fall through and everything prints.
4. Forgetting to update the loop variable — while (i < 10) with no i++ inside loops forever.
5. Off-by-one errors — <= vs < decides whether you get 10 iterations or 11. When loops misbehave by exactly one, check the comparison operator first.

(Suggested image: "5 Control Flow Traps" checklist graphic — consistent with the series)

A Complete Example: A Number Guessing Game

Everything from this page working together:

#include <stdio.h>
int main() {
    int secret = 42;
    int guess, attempts = 0;
    puts("=== Number Guessing Game ===");
    puts("I'm thinking of a number between 1 and 100.");
    while (1) {
        // loop until break
        printf("Your guess: ");
        scanf("%d", &guess);
        attempts++;
        if (guess < 1 || guess > 100) {
            puts("Out of range! Try 1-100.");
            continue;
            // skip the rest, guess again
        }
        if (guess < secret) {
            puts("Too low!");
        } else if (guess > secret) {
            puts("Too high!");
        } else {
            printf("Correct! You got it in %d attempts.\n", attempts);
            break;
            // exit the loop
        }
    }
    if (attempts <= 5) {
        puts("Amazing — you're a natural!");
    } else if (attempts <= 10) {
        puts("Well played!");
    } else {
        puts("Persistence pays off!");
    }
    return 0;
}

Sample Run:

=== Number Guessing Game ===
I'm thinking of a number between 1 and
100.
Your guess: 50
Too high!
Your guess: 25
Too low!
Your guess: 42
Correct! You got it in 3 attempts.
Amazing — you're a natural!

An infinite while(1) controlled by break, validation via continue, and a multi-way if-else chain — three control flow tools cooperating in twenty lines. That's the whole page, working.

Final Thoughts

Control flow is where C stops being a calculator and starts being a language. From this point forward, every program you write will be some combination of these ideas: choose with if/switch, repeat with loops, escape with break/continue.

If the variety feels like a lot, relax — within a few programs, choosing the right statement becomes pure instinct. For now, remember the map: decisions, loops, jumps. Every deep-dive tutorial that follows in this series zooms into one square of that map.