Control Flow

So far our programs have executed top to bottom, one line at a time. Real programs need to make decisions and repeat work. The constructs that let them do so — if, switch, while, for, break, continue, return — are collectively called control flow.

A useful mental model: at every moment, the CPU is following exactly one path through your program. Control-flow statements are forks and loops in that path.

Sequential flow

The simplest flow is straight-line execution: one statement after another.

Every program starts this way at main's opening brace.

if and else: decisions

An if statement tests a condition (a bool expression) and runs its block only when the condition is true. An optional else block runs when the condition is false.

else can chain into another if, building a ladder:

Two beginner footguns:

1. = is assignment, == is comparison. if (x = 5) compiles (it assigns 5 to x, then tests truthiness), and it is almost never what you meant.
2. Always use braces. Without braces, only the next single statement belongs to the if. This is a famous source of security bugs (the "goto fail" incident in Apple's TLS code).

// dangerous:
if (logged_in)
    grant_access();
    audit();         // <-- always runs, regardless of logged_in!

// safe:
if (logged_in) {
    grant_access();
    audit();
}

Boolean operators

Conditions can be combined with:

• && — logical AND (true only if both sides are true)
• || — logical OR (true if either side is true)
• ! — logical NOT (flips true/false)

Both && and || are short-circuited: the right side is only evaluated if the left side could not already determine the answer. This is what lets you write if (p != nullptr && p->value > 0) safely.

switch: multi-way dispatch

When the same expression should be compared against many specific constant values, switch is clearer than a ladder of else ifs.

A few rules:

• Each case must be a constant known at compile time (an int, a char, or an enum).
• Without break, execution falls through to the next case. That is rarely what you want; almost always include break.
• default handles any value not matched.

while: loop with a condition

A while loop runs its body as long as the condition is true. The condition is checked before each iteration; if it's false the first time, the body never runs at all.

A do { ... } while (cond); variant exists where the body runs first, then the condition is checked. It is rarely needed but useful for prompt-and-validate loops.

for: counting loops

The for loop bundles three pieces of a typical counting loop (initialization, condition, increment) into a single header:

for (init; condition; update) {
    body
}

The variable declared inside the for header (here i) is scoped to the loop only. After the loop, i is gone. Good — that's exactly the smallest-scope principle we mentioned earlier.

Range-based for

For containers (and anything with .begin() / .end()), the range-based for is cleaner:

Notes:

• const std::string& says "I'll just read each element, by reference." Without the &, each element would be copied, which would be wasteful for big strings.
• You can also use auto: for (const auto& name : names) ...

break and continue

Inside any loop:

• break exits the loop entirely.
• continue skips the rest of the current iteration and jumps back to the condition (or to the update for for).

Use these sparingly. A loop with three breaks and four continues is usually a sign that the condition could be rewritten more cleanly.

Infinite loops on purpose

Sometimes you do want a loop that runs forever and is exited by an internal condition. Two idiomatic forms:

while (true) { ... }
for (;;)     { ... }

Both compile to the same code. Use whichever you find clearer.

Mapping algorithms to control flow

When you turn an algorithm into code, every "for each" becomes a loop, every "if/then" becomes an if, and every "do until" becomes a while. Practice that translation by writing the algorithm in English first.

Algorithm: "Print the first 10 Fibonacci numbers."

1. Start with a = 0, b = 1.
2. Print a.
3. Compute c = a + b. Set a = b, b = c.
4. Repeat steps 2–3 nine more times.

Common loop bugs

Challenges

Test your understanding

Next: how to package code into reusable units — functions.