Control Flow

Conditional statements

if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else {
    grade = 'C';
}

switch

switch (token) {
case '+':
    handle_add();
    break;
case '-':
    handle_subtract();
    break;
default:
    handle_unknown();
    break;
}

Loops

for (int i = 0; i < 10; ++i) {
    total += i;
}

while (!done) {
    poll();
}

do {
    read_again();
} while (retry);

Range-based for

for (const auto& item : items) {
    std::cout << item << '\n';
}

Loop control

• break: exit the nearest loop or switch
• continue: skip to the next iteration
• return: leave the current function

if with initializer

if (auto it = map.find(key); it != map.end()) {
    use(it->second);
}

switch with enums

enum class State { idle, running, done };

Prefer enum class to avoid accidental implicit conversions.

Best-practice reminders

• Prefer early returns over deeply nested conditions.
• Use range-based loops for readability.
• Use algorithms when expressing transformations or searches.
• Keep loop bodies small and obvious.

Quick decision guide

• use if when you are making one or two related decisions based on conditions
• use switch when one value selects among several named cases
• use a loop when work repeats until data ends or a condition changes
• use an algorithm when the real intent is search, transform, count, partition, or accumulate

constexpr if

template <typename T>
void print_kind(const T& value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "integral: " << value << '\n';
    } else {
        std::cout << "other: " << value << '\n';
    }
}

Use if constexpr in templates when a branch should disappear entirely for some types.

Modern switch habits

switch (state) {
case State::idle:
    start();
    break;
case State::running:
    [[fallthrough]];
case State::paused:
    resume();
    break;
}

• Prefer enum class inputs.
• Mark intentional fallthrough explicitly.
• Keep complex work in helper functions instead of large case blocks.

Loop pitfalls worth remembering

• Prefer preincrement for iterators by habit: ++it.
• Be careful with signed/unsigned comparisons such as i < values.size().
• Do not erase from a container while iterating unless the container API documents the safe pattern.

Guard-clause pattern

bool handle_request(const Request& request) {
    if (!request.authenticated()) {
        return false;
    }
    if (!request.has_payload()) {
        return false;
    }

    process(request.payload());
    return true;
}

This is usually easier to scan than pushing the main logic into another indentation level.

Small state-machine pattern

switch (state) {
case State::idle:
    start();
    break;
case State::running:
    step();
    break;
case State::done:
    cleanup();
    break;
}

When a switch starts accumulating too much work per case, move each branch into a helper so the state transition stays obvious.