C++ Loops

int choice;
do {
    std::cout << "Enter 1-5: ";
    std::cin >> choice;
} while (choice < 1 || choice > 5);

A do-while loop runs its body FIRST, then checks the condition — meaning the body always runs at least once, even if the condition would've been false from the start. This fits menu-style prompts perfectly: you have to ask the user for input at least once before you have anything to validate.

for (int i = 0; i < 20; i++) {
    std::cout << "Push-up #" << (i + 1) << std::endl;
}

This is exactly equivalent to a while loop with the counter setup, condition, and increment all written manually — for just bundles all three into one compact, less error-prone line, specifically because forgetting the increment (Module 1's classic bug) is much harder when it's built right into the loop's own header.

Both are fully capable of doing either job — this is a readability convention, not a hard technical rule.

for (int row = 1; row <= 3; row++) {
    for (int col = 1; col <= 3; col++) {
        std::cout << row * col << " ";
    }
    std::cout << std::endl;
}

For every single repetition of the OUTER loop (each row), the ENTIRE inner loop runs completely (all three columns) before the outer loop moves to its next repetition. This produces a 3×3 multiplication grid, one row printed per outer-loop repetition.

If the outer loop runs 3 times and the inner loop runs 3 times for EACH of those, the inner loop's body actually executes 3 × 3 = 9 times total. This multiplies quickly — a 100×100 nested loop runs its innermost code 10,000 times — which matters once you start thinking about how long a program takes to run on larger amounts of data.

for (int i = 1; i <= 100; i++) {
    if (i == 10) {
        break;   // exits the loop entirely, right here
    }
    std::cout << i << " ";
}
// prints 1 2 3 4 5 6 7 8 9, then stops — the loop never reaches 100

break immediately stops the loop, regardless of its normal condition — useful for something like searching a list and stopping the moment you find what you're looking for, instead of wastefully continuing to check everything else.

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;   // skip printing even numbers
    }
    std::cout << i << " ";
}
// prints 1 3 5 7 9 — evens are skipped, but the loop keeps going

Unlike break, continue doesn't exit the loop — it just skips the REST of the current repetition's body and jumps straight to the next one (running the update step, then re-checking the condition, as normal).

Building up a running total across repetitions:

int total = 0;
for (int i = 1; i <= 10; i++) {
    total += i;   // total = total + i
}
// total is now 55 (1+2+3+...+10)

The variable being accumulated into (total) must be declared and initialized BEFORE the loop starts — a genuinely common mistake is declaring it inside the loop, which resets it to 0 every single repetition instead of accumulating.

Looking for a specific item and stopping once found, using break from the last lesson:

bool found = false;
for (int i = 1; i <= 100; i++) {
    if (i == targetValue) {
        found = true;
        break;
    }
}

Repeating until the user enters a special "stop" value:

int number;
std::cout << "Enter numbers, or -1 to stop: ";
std::cin >> number;
while (number != -1) {
    std::cout << "You entered: " << number << std::endl;
    std::cin >> number;
}

Notice the input is read TWICE — once before the loop starts (to have something to check the very first time) and once at the end of every repetition (to get the next value). This shape is worth recognizing on sight.

for (int i = 0; i < 10; i++)   // runs 10 times: 0,1,2...9
for (int i = 0; i <= 10; i++)  // runs 11 times: 0,1,2...10

The difference between < and <= shifts the total number of repetitions by exactly one — this class of mistake is common enough to have its own name ("off-by-one") and is genuinely easy to introduce even once you're experienced. When a loop's count seems wrong by exactly one, this is the very first thing to check.

Changing the loop's counter variable somewhere inside the body — separately from the loop's own update step — makes the loop's behavior confusing and hard to predict. It's technically legal C++, but almost always a sign of a design that should be restructured.

Module 1 already covered the classic version (forgetting to update the condition variable). A second common version: a condition that can genuinely never become false due to a logic mistake — like accidentally using || (OR) where you meant && (AND), making the condition true far more often than intended.

The computer picks a secret number between 1 and 100. The player guesses repeatedly; after each guess, the program says "too high," "too low," or "correct!" — and tracks how many guesses it took.

• The while (guess != secret) condition is a direct application of Module 1 — keep going until the exact right condition is met.
• attempts is the accumulator pattern from Module 6, counting up by one each repetition.
• The if/else-if/else chain inside the loop is Phase 1's Module 8, reused here to give feedback each guess.