2.1 Conditionals and Control Flow

Every programming language needs a way to make decisions based on conditions. In C++, we control execution flow using if, else if, and else blocks, as well as switch statements.

Let's look at how to construct basic decision making branches, and then explore how the hardware optimizes these paths behind the scenes.

Conditionals evaluate expressions that result in a boolean value (true or false). Here is the standard syntax for conditional branching:

#include <iostream>

int main() {
    int score{85};

    if (score >= 90) {
        std::cout << "Grade: A\n";
    } else if (score >= 80) {
        std::cout << "Grade: B\n"; // This block executes!
    } else {
        std::cout << "Grade: C\n";
    }
    return 0;
}

When you evaluate compound logical expressions using AND (&&) or OR (||), C++ performs short circuit evaluation. The compiler stops evaluating as soon as the final result is known.

• For &&, if the left hand condition is false, the overall expression can never be true, so the right hand condition is skipped.

• For ||, if the left hand condition is true, the overall expression is guaranteed to be true, so the right hand condition is skipped.

This short circuiting behavior is extremely useful as a safety guard to prevent crashes, such as accessing a pointer only if it is not null:

int* ptr{nullptr};

// Safe! Since ptr is nullptr (false), the right side is never executed,
// preventing a segmentation fault crash!
if (ptr != nullptr && *ptr == 100) {
    std::cout << "Value matches!\n";
}

If you have multiple discrete integer or character states to check, a switch statement is cleaner than a chain of if-else blocks. Use break at the end of each case unless fall-through is intentional, accidental fall-through is a common source of bugs:

#include <iostream>

int main() {
    char grade{'B'};

    switch (grade) {
        case 'A':
            std::cout << "Excellent!\n";
            break;
        case 'B':
            std::cout << "Good job!\n"; // This executes!
            break;
        default:
            std::cout << "Keep trying!\n";
            break;
    }
    return 0;
}

For high performance applications, decision making is a highly optimized, speculative process where the compiler and CPU work together to pre fetch instructions.

1. Conditional Compilation and CPU Jumps

When you write an if statement, the compiler translates it into a comparison instruction (such as cmp on x86_64) followed by a conditional jump instruction (like je for jump if equal, jl for jump if less):

int checkAge(int age) {
    if (age < 18) {
        return 0;
    }
    return 1;
}

// Generated x86_64 Assembly
checkAge:
    cmp     edi, 17          ; Compare input age register (edi) to 17
    jg      .L2              ; If greater than 17, jump to branch L2
    mov     eax, 0           ; Otherwise, load 0 into return register
    ret                      ; Return control
.L2:
    mov     eax, 1           ; Load 1 into return register
    ret

2. Hardware Branch Prediction

To speed up execution, modern CPUs load multiple instructions into memory ahead of time (instruction pipelining). When the CPU hits a branch, it does not know which instruction to load next until the comparison completes. If it stops and waits, the pipeline empties, costing precious cycles (a pipeline bubble).

To avoid this, the CPU uses a Branch Predictor to guess which branch will execute based on recent history. A branch misprediction forces the pipeline to discard speculative work, often on the order of 10 to 20 cycles on contemporary out-of-order cores.

3. The Sorted vs Unsorted Array Performance Paradox

A classic micro-benchmark: processing a sorted array is often much faster than processing an unsorted one with the same data. Branch predictors can learn a sorted threshold pattern (all falses, then all trues), but compilers may also vectorize sorted loops differently. Treat the gap as a hypothesis until you inspect assembly on your machine (Lessons 0.4 and 9.9). Note that std::sort mutates the array, so the second loop also benefits from sort order and a warm cache:

#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>
#include <cstdlib>

int main() {
    const unsigned int arraySize{32768};
    std::vector<int> data(arraySize);

    for (unsigned int i{0}; i < arraySize; ++i) {
        data[i] = std::rand() % 256;
    }

    auto startUnsorted = std::chrono::high_resolution_clock::now();
    long long sumUnsorted{0};
    for (int val : data) {
        if (val >= 128) sumUnsorted += val;
    }
    auto endUnsorted = std::chrono::high_resolution_clock::now();

    std::sort(data.begin(), data.end());
    auto startSorted = std::chrono::high_resolution_clock::now();
    long long sumSorted{0};
    for (int val : data) {
        if (val >= 128) sumSorted += val;
    }
    auto endSorted = std::chrono::high_resolution_clock::now();

    const auto unsortedUs = std::chrono::duration_cast<std::chrono::microseconds>(endUnsorted - startUnsorted).count();
    const auto sortedUs = std::chrono::duration_cast<std::chrono::microseconds>(endSorted - startSorted).count();
    std::cout << "Unsorted: " << unsortedUs << " us, Sorted: " << sortedUs << " us\n";
    std::cout << "Sums match: " << std::boolalpha << (sumUnsorted == sumSorted) << '\n';
    return 0;
}

4. Switch Statement Jump Tables

For a dense switch, a compiler may choose a jump table; for sparse or small cases it may choose comparisons, a binary search, or another representation. This is a compiler-and-input decision, so inspect generated code only after profiling identifies the branch as important.