Loops, Control Variables and Iteration

Learning objectives

• Choose between counted for, range-based for and sentinel-controlled while or for loops.
• Keep loop control variables monotonic and separate from user input or unrelated state.
• Use index bounds that match container size and avoid off-by-one errors.
• Compare index-based loops with range-based loops and standard algorithms.
• Repair a flawed input loop by separating control, input and termination.

Key vocabulary before you start

Example: counted loop vs range-based loop

Both loops sum even values. The counted loop exposes indices; the range-based loop exposes intent.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6};

    int sum = 0;
    for (size_t i = 0, n = v.size(); i < n; ++i) {
        if (v[i] % 2 == 0) sum += v[i];
    }
    std::cout << "sum=" << sum << '\n';

    int sum2 = 0;
    for (int x : v) {
        if ((x & 1) == 0) sum2 += x;
    }
    std::cout << "sum2=" << sum2 << '\n';
}

Visual model: loop reasoning cycle

A loop is safe only when setup, progress and termination can all be stated clearly.

Choose the loop form

Use a counted for loop when the iteration count or index position matters. The control variable should move predictably toward termination.

Use a range-based for loop when the task is element-focused and does not need indices. This often communicates intent better than manual indexing.

Use a while loop, or a for loop with the condition in the middle slot, when repetition is controlled by input, a sentinel value or an external condition.

Control variable discipline

The loop control variable should be boring: initialised clearly, changed predictably and tested against a visible termination condition.

Do not use the control variable as the place where user input is stored. That makes the loop's progress depend on external values and creates fragile behaviour.

If user input controls termination, name it as input and express the sentinel condition directly.

Bounds, locality and measurement

For zero-based indexing, prefer i < size to i <= size - 1. It is easier to read, handles empty ranges more naturally and matches iterator-style thinking.

Use size_t or an appropriate container size type when comparing against container sizes. Avoid signed/unsigned mismatches unless you have a deliberate reason.

Maximise locality where it supports clarity: contiguous data, simple branches and predictable strides are friendly to modern hardware. Write clear loops first, then measure before optimising.

From loops to algorithms

A clear loop is often the right first expression of an idea. Once the intent is stable, consider whether a standard algorithm or ranges pipeline communicates it better.

std::accumulate, std::count_if, std::copy_if and C++ ranges can reduce incidental loop mechanics, but they can also hide simple logic behind unfamiliar abstractions.

The trade-off is not loops versus cleverness. It is whether the code makes traversal, filtering, accumulation and cost easier to inspect.

// Counted for
int sum = 0;
for (size_t i = 0, n = v.size(); i < n; ++i) {
    if (v[i] % 2 == 0) sum += v[i];
}
std::cout << "sum=" << sum << '\n';

// Range-based for (clearer intent)
int sum2 = 0;
for (int x : v) {
    if ((x & 1) == 0) sum2 += x;
}
std::cout << "sum2=" << sum2 << '\n';

Summary checklist

Use for when iteration count is known, range-based for when you just need elements and while when a sentinel controls input.

Keep the control variable monotonic and separate from user inputs or side effects.

Prefer < to <= for index bounds, and use size_t or another appropriate size type for sizes and indices.

Maximise locality with contiguous data, simple branches and predictable strides.

Let the compiler optimise. Write clear loops first, then measure.

Applied case lab

Applied task: Fix the Loop

Repair flawed loop control by separating loop state, user input and termination conditions.

Stage 1: read and classify

int x = 100;
for (int y = 0; y < x; ++y) {
    std::cin >> y; // wrong: y is both control and input
    std::cout << x + y << '\n';
}

int x = 100;
for (int input = 0; std::cin >> input && input != 0; ) {
    std::cout << x + input << '\n';
}

Stage 2: trace or repair

int x = 100;
int input = 0;
// TODO: read until input is 0

int x = 100;
int input = 0;
while (std::cin >> input && input != 0) {
    std::cout << x + input << '\n';
}

Stage 3: justify the design

int sum = 0;
for (int x : v) {
    if ((x & 1) == 0) sum += x;
}

int sum = std::accumulate(v.begin(), v.end(), 0, [](int total, int x) {
    return (x % 2 == 0) ? total + x : total;
});

Quick checks

AI-augmented practice notes

Use these as prompts for disciplined support, not as permission to outsource judgement.

Assessment tasks

1. Repair the broken input loop and explain why the original mixed control and input state.
2. Write counted, range-based and sentinel-controlled versions of small loops and justify each choice.
3. Rewrite one loop as a standard algorithm, then decide which version you would keep.
4. Create a loop trace table for an input sequence ending in 0.

Judgement questions