Control Flow — if, switch, loops

Every algorithm boils down to choose and repeat. C++ gives you a full toolkit and modern C++ keeps adding small, sharp upgrades.

Boolean Conditions

Conditions are anything convertible to bool. Numbers: 0 = false, anything else = true. Pointers: nullptr = false.

if (count)        cout << "non-zero";
if (!ptr)         cout << "null";
if (s.empty())    cout << "empty string";

Logical Operators

if (p != nullptr && p->valid())   // safe — if p is null, p->valid() never runs

Comparison

== != < <= > >= — and <=> (C++20 *spaceship operator*) for three-way comparisons.

> ⚠️ = vs == — if (x = 5) assigns 5 to x and is always true. Most compilers warn about this. Always == in conditions.

if, else, else if

if (cond) {
    // ...
} else if (other) {
    // ...
} else {
    // ...
}

Use braces { } even for one-line bodies — saves you from the famous "Apple goto-fail" bug:

if (cond)
    doA();
    doB();      // ALWAYS runs — not what you might have meant

if With Init (C++17)

Limit a variable's scope to the if:

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

C++20 added the same for switch and for.

Conditional Operator

int abs = (x < 0) ? -x : x;

Great for short choices. Don't nest more than one level — readability dies fast.

switch

For exact-value matches on integers, enums, or characters.

switch (cmd) {
    case 'q': quit(); break;
    case 'h':
    case '?': showHelp(); break;       // intentional fall-through
    default:  cout << "unknown"; break;
}

Fall-Through

By default, control flows from one matching case into the next until a break. C++17 lets you mark intentional fall-through:

switch (x) {
    case 1:
        a();
        [[fallthrough]];   // tells the compiler "yes, on purpose"
    case 2:
        b();
        break;
}

Classic for Loop

for (init; condition; step) {
    // body
}

for (int i = 0; i < n; ++i) cout << i;
for (int i = n - 1; i >= 0; --i) cout << i;     // backwards
for (int i = 0, j = n - 1; i < j; ++i, --j) ;   // two cursors

++i is conventional in C++. For ints it's identical to i++, but for iterators ++i is sometimes faster (no temporary).

while & do…while

while (n > 1) {
    if (n % 2 == 0) n /= 2;
    else            n = 3*n + 1;     // Collatz!
}
do {
    cout << "Try again> ";
    cin >> guess;
} while (guess != answer);

Use while when you might do zero iterations; do…while when you need at least one.

Range-Based for (C++11)

The cleanest way to iterate over containers, arrays, strings, anything with begin()/end().

vector<int> v = {1, 2, 3};
for (int x : v) cout << x;            // copy each element
for (int& x : v) x += 10;              // modify in place
for (const auto& s : names) cout << s; // big elements: const ref to avoid copies

Pattern: auto& to modify, const auto& to read.

Loop Control: break & continue

for (int x : nums) {
    if (x < 0) continue;       // skip negatives
    if (x == 0) break;          // stop at first zero
    cout << x << ' ';
}

Breaking Out of Nested Loops

C++ has no labelled break. Common idioms:

bool done = false;
for (int i = 0; i < n && !done; ++i)
    for (int j = 0; j < n; ++j)
        if (grid[i][j] == target) { done = true; break; }

Or just put it in a function and use return. Cleaner.

goto?

C++ has goto. Don't use it for normal flow. The one defensible use is jumping to a single cleanup label in deeply nested C-style code — and even then, RAII is better.

Common Bugs

Master these and you can express any algorithm. The next phase introduces functions — a way to package the control flow you write here.