> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Do-While Loop A `do-while` loop in C++ is a post-test control flow statement that guarantees the execution of its enclosed block of code at least once. Unlike a standard `while` loop, which evaluates its condition prior to execution (pre-test), the `do-while` loop executes the loop body first and evaluates its boolean expression at the end of the iteration. ## Syntax ```cpp theme={"dark"} do { // Loop body: Statements to execute } while (condition); ``` **Critical Syntax Note:** The `while (condition)` statement at the end of the loop must be explicitly terminated with a semicolon (`;`). Omitting this is a common compilation error. ## Execution Mechanics 1. **Execution:** The program enters the `do` block and executes the statements sequentially. 2. **Evaluation:** After the block executes, the `condition` is evaluated. This condition must yield a boolean value (`true` or `false`) or a type convertible to a boolean (where non-zero is `true` and zero is `false`). 3. **Branching:** * If the condition evaluates to `true`, control flow jumps back to the beginning of the `do` block for the next iteration. * If the condition evaluates to `false`, the loop terminates, and control flow proceeds to the next statement immediately following the `do-while` construct. ## Variable Scope Variables declared within the `do` block are strictly local to that block. They are destroyed at the end of the iteration and **cannot** be accessed within the `while` condition. Any variable evaluated in the condition must be declared in an outer scope prior to the `do` statement. ```cpp theme={"dark"} // Incorrect Scope do { int x = 5; --x; } while (x > 0); // ERROR: 'x' is out of scope // Correct Scope int x = 5; do { --x; } while (x > 0); // Valid ``` ## Loop Control Statements * **`break`**: Immediately terminates the `do-while` loop. Control flow jumps to the statement following the loop, bypassing the condition evaluation entirely. * **`continue`**: Skips the remaining statements in the current iteration of the `do` block and jumps directly to the `while (condition)` evaluation to determine if the next iteration should occur. ## Mechanical Example The following code demonstrates the guaranteed single execution and subsequent condition evaluation: ```cpp theme={"dark"} #include int main() { int counter = 5; do { std::cout << "Counter value: " << counter << '\n'; --counter; } while (counter > 5); // Output will be "Counter value: 5" exactly once, // because the condition (4 > 5) evaluates to false after the first pass. return 0; } ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More