While and Do-While Loops: Non-Deterministic Iteration

Trace the state

1. while checks x < 5 before entering the body.
2. If the initial condition is false, the while body executes zero times.
3. do-while executes the body first, then checks the condition.
4. Both loops rely on ++x, --y or another explicit state update to move state toward termination.

Exit-reason task

For each loop in the mini exercise, name the exact exit reason and the value that proves progress.

Applied task

Given a task description, choose for, while or do-while, then state the invariant and termination condition.

Example: first-condition vs final-condition

The difference is visible when the initial state already fails the condition.

// while: may not run at all
int x = 0;
while (x < 5) {
    ++x;
}

// do-while: runs at least once
int y = 10;
do {
    --y;
} while (y > 10);

Applied task

Choose an initial value that makes a while loop run zero times, then explain what a do-while version would do.

Read until zero

The condition both consumes input and tests the sentinel.

#include <iostream>

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

Applied task

Explain why putting std::cin >> value in the condition prevents the loop from processing a stale value.

Wrong: checking eof before reading

The final iteration may reuse the previous line.

#include <fstream>
#include <string>

std::ifstream in("data.txt");
std::string line;
while (!in.eof()) {
    std::getline(in, line);
    // last iteration may process stale 'line'
}

Right: read as the condition

The body only executes when getline succeeds.

std::ifstream in("data.txt");
std::string line;
while (std::getline(in, line)) {
    // use 'line'
}

Applied task

Rewrite one while(!stream.eof()) loop so the read operation controls entry to the loop body.

Menu shown at least once

A switch keeps the actions readable while the do-while guarantees the prompt appears at least once.

#include <iostream>

int main() {
    char choice{};
    do {
        std::cout << "[A]dd [R]emove [Q]uit: ";
        if (!(std::cin >> choice)) break; // input failed

        switch (choice) {
            case 'A': case 'a': /* add(); */ break;
            case 'R': case 'r': /* remove(); */ break;
            case 'Q': case 'q': std::cout << "Bye!\n"; break;
            default: std::cout << "Unknown option\n"; break;
        }
    } while (choice != 'Q' && choice != 'q');
}

Applied task

Identify the sentinel, the state that changes and the reason a do-while communicates the menu requirement clearly.

Bound a loop by attempts and time

The loop exits on failure, after too many attempts or after a deadline.

#include <chrono>

bool work_once();

bool bounded_loop() {
    using clock = std::chrono::steady_clock;
    auto deadline = clock::now() + std::chrono::seconds(2);
    int attempts = 0;
    const int max_attempts = 10000;

    while (clock::now() < deadline && attempts < max_attempts) {
        if (!work_once()) break; // escape on failure
        ++attempts;
    }
    return attempts > 0;
}

Applied task

For a polling loop, state what each escape hatch means: success, failure, timeout and max-attempt exhaustion.

Infinite loop: condition never changes

The condition depends on n, but the body never moves n toward zero.

int n = 5;
while (n > 0) {
    std::cout << n << '\n';
    // forgot: --n;
}

Applied task

List every variable in one loop condition and point to the exact statement that changes each one.

Read unknown lines and unknown tokens

Each loop condition performs the read operation that makes the body safe.

#include <fstream>
#include <sstream>
#include <iostream>
#include <string>

int main() {
    std::ifstream in("nums.txt");
    if (!in) {
        std::cerr << "Cannot open file\n";
        return 1;
    }

    long long sum = 0;
    std::string line;
    while (std::getline(in, line)) {
        std::istringstream iss(line);
        long long x;
        while (iss >> x) {
            sum += x;
        }
    }
    std::cout << "Total = " << sum << '\n';
}

Applied task

Identify the progress point for the outer loop and the progress point for the inner loop.

Applied task

Use the checklist to review one loop from your own codebase.

Applied task

For one while loop, write the invariant, the changing state and the exact reason it must eventually stop.

Applied task

Rewrite a while(true) loop so the condition states why the loop continues.

Case 1: Unknown input length

A program reads numbers until the user enters 0. Decide whether this should be a counted for, a while or a do-while, and state the sentinel.

Case 2: Mandatory first attempt

A menu should display at least once before checking whether the user wants to quit. Decide whether do-while communicates that better than while.

Case 3: Polling a device

A loop polls until a device is ready. Identify the progress state, timeout strategy and error exit.

A. Choose the loop

Classify each task as for, while or do-while.

// 1. Print exactly 10 rows.
// 2. Read values until 0.
// 3. Show a menu at least once, then repeat until Quit.
// 4. Poll until ready or timeout.

• Choose a loop form for each task.
• State what controls termination.
• Identify which tasks may execute zero times and which must execute once.

1 -> counted for
2 -> while or condition-driven for
3 -> do-while
4 -> while with timeout/error state

B. Repair while(true)

Move the real continuation rule into the condition.

while (true) {
    std::cin >> input;
    if (input == 0) break;
    process(input);
}

• Rewrite the loop without while(true).
• Handle failed input as well as sentinel input.
• Explain which state changes each iteration.

while (std::cin >> input && input != 0) {
    process(input);
}

C. Prove termination

This loop looks simple, but the proof depends on progress.

int x = 10;
while (x > 0) {
    // TODO: make progress
}

• Add a state update that guarantees termination.
• State the decreasing measure.
• Explain how the loop could become infinite.

int x = 10;
while (x > 0) {
    --x; // decreasing measure: x moves toward 0
}

D. Repair stale file input

The loop checks EOF before attempting the read.

std::ifstream in("data.txt");
std::string line;
while (!in.eof()) {
    std::getline(in, line);
    process(line);
}

• Explain why the loop can process a stale line.
• Move the read into the condition.
• State the exact condition that permits process(line) to run.

std::ifstream in("data.txt");
std::string line;
while (std::getline(in, line)) {
    process(line);
}

E. Choose do-while for a menu

The user must see the menu before choosing whether to quit.

int choice{};
// TODO: show menu at least once, then repeat until choice == 0

• Write a do-while loop for the menu.
• Name the sentinel value.
• Add a failed-input guard.

char choice{};
do {
    std::cout << "[A]dd [R]emove [Q]uit: ";
    if (!(std::cin >> choice)) break;
    switch (choice) {
        case 'A': case 'a': add(); break;
        case 'R': case 'r': remove(); break;
        case 'Q': case 'q': std::cout << "Bye!\n"; break;
        default: std::cout << "Unknown option\n"; break;
    }
} while (choice != 'Q' && choice != 'q');

F. Add escape hatches

This polling loop has no upper bound.

while (!ready()) {
    work_once();
}

• Add a max-iteration counter.
• Add a steady_clock deadline.
• Document what each exit path means.

using clock = std::chrono::steady_clock;
auto deadline = clock::now() + std::chrono::seconds(2);
int attempts = 0;
const int max_attempts = 10000;
while (!ready() && attempts < max_attempts && clock::now() < deadline) {
    if (!work_once()) break;
    ++attempts;
}

G. From while(true) to correct logic

This loop should read tokens until EOF or quit, but malformed input can leave stale state.

#include <iostream>
#include <string>

int main() {
    std::string s;
    while (true) {
        std::cin >> s; // may fail and leave 's' unchanged
        if (s == "quit") break;
        std::cout << s << '\n';
    }
}

• Make the read operation the condition.
• Keep quit as the sentinel.
• Explain what happens on EOF or input failure.

int main() {
    std::string s;
    while (std::cin >> s) {
        if (s == "quit") break;
        std::cout << s << '\n';
    }
}