{"title":"Do-While Loop","description":null,"content":"The `do-while` loop is the one loop in C++ that always runs its body at least once before checking the condition. That single property makes it the right tool for a small but real set of problems: prompting a user until they enter something valid, showing a menu that repeats until they pick \"exit\", and retrying an operation a couple of times before giving up. This lesson covers the syntax, the issue with the trailing semicolon, and the situations where `do-while` reads more naturally than a regular `while`.\n\n---\n\n# Syntax and Basic Behavior\n\nA `do-while` loop has three parts: the keyword `do`, a body in curly braces, and a `while (condition);` clause at the bottom. That trailing semicolon is mandatory, and forgetting it is one of the most common mistakes when first learning the construct.\n\n\n```cpp\n#include \n\nint main() {\n int orderCount{0};\n\n do {\n std::cout << \"Processing order \" << orderCount << std::endl;\n orderCount++;\n } while (orderCount < 3);\n\n std::cout << \"Done. Total orders processed: \" << orderCount << std::endl;\n return 0;\n}\n```\n\n\nThe flow is straightforward: enter the body, run it, then check the condition. If the condition is `true`, jump back to the top of the body and run it again. If it's `false`, fall through to whatever comes next.\n\nThe key behavior that sets `do-while` apart from `while` is the order of those two steps. The body runs first, then the condition is checked. Even if the condition is `false` from the start, the body still runs once.\n\n\n```cpp\n#include \n\nint main() {\n int stock{0};\n\n do {\n std::cout << \"Checking stock: \" << stock << std::endl;\n } while (stock > 0);\n\n std::cout << \"Loop finished\" << std::endl;\n return 0;\n}\n```\n\n\n`stock` is `0` from the start, so `stock > 0` is `false` the first time it's checked. But the body still ran once, because the check happens at the end of the iteration, not the beginning. With a regular `while` loop, that body would never execute.\n\n---\n\n# The Trailing Semicolon\n\nThe semicolon after `while (condition)` is not optional. It's part of the `do-while` statement's syntax. Leaving it off produces a compiler error that's often confusing because it points at the next line, not at the missing semicolon.\n\n**What's wrong with this code?**\n\n\n```cpp\n#include \n\nint main() {\n int retries{0};\n do {\n retries++;\n } while (retries < 3) // missing semicolon\n std::cout << \"Retries: \" << retries << std::endl;\n return 0;\n}\n```\n\n\nWith `g++ -std=c++17`, this fails with something like:\n\n\n```shell\nerror: expected ';' before 'std'\n } while (retries < 3)\n ^\n ;\n std::cout << \"Retries: \" << retries << std::endl;\n ~~~\n```\n\n\nThe compiler keeps reading past the `while (...)` looking for the semicolon, sees `std::cout` instead, and complains. The fix is to add the missing `;` after the parenthesis:\n\n\n```cpp\n} while (retries < 3);\n```\n\n\nThis is a different shape from `for` and `while` loops, where the body's closing brace `}` ends the statement and no extra semicolon is needed. The asymmetry is intentional: `do-while` ends with an expression-statement (`while (cond);`), so it needs the semicolon the same way `int x = 5;` does.\n\n---\n\n# While vs Do-While, Side by Side\n\nThe difference between `while` and `do-while` comes down to one question: should the body run at least once, regardless of the condition? A side-by-side comparison makes the contrast obvious.\n\nSame logic, written two ways:\n\n\n```cpp\n#include \n\nint main() {\n int cartItems{0};\n\n // Version 1: while loop\n std::cout << \"while loop:\" << std::endl;\n while (cartItems > 0) {\n std::cout << \" Processing item \" << cartItems << std::endl;\n cartItems--;\n }\n\n // Version 2: do-while loop\n std::cout << \"do-while loop:\" << std::endl;\n do {\n std::cout << \" Processing item \" << cartItems << std::endl;\n cartItems--;\n } while (cartItems > 0);\n\n return 0;\n}\n```\n\n\n`cartItems` starts at `0`. The `while` version checks the condition first, sees that `0 > 0` is `false`, and skips the body entirely. The `do-while` version runs the body once before checking, prints `Processing item 0`, decrements `cartItems` to `-1`, and only then checks `cartItems > 0`, which is `false`.\n\nThis zero-iterations difference is the whole point. Sometimes it's the right answer, sometimes it's a bug. Picking between the two loops is picking which behavior is intended.\n\nThe general shape of each:\n\n\n```mermaid\nflowchart TD\n subgraph WhileLoop[\"while loop\"]\n W1[Start]:::cyan --> W2{Check
condition}:::orange\n W2 -->|true| W3[Run body]:::green\n W3 --> W2\n W2 -->|false| W4[Exit]:::red\n end\n\n subgraph DoWhileLoop[\"do-while loop\"]\n D1[Start]:::cyan --> D2[Run body]:::green\n D2 --> D3{Check
condition}:::orange\n D3 -->|true| D2\n D3 -->|false| D4[Exit]:::red\n end\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nIn the `while` shape, the first arrow goes into the check. In the `do-while` shape, it goes into the body. That's the whole story, and it drives every decision about when to use one versus the other.\n\nA summary table for quick reference:\n\n\n| Property | `while` | `do-while` |\n|---|---|---|\n| Where condition is checked | Before each iteration | After each iteration |\n| Minimum body executions | 0 | 1 |\n| Trailing semicolon? | No | Yes, after `while (...)` |\n| Best for | Pre-tested loops, \"loop while data is available\" | Input validation, menus, retry-then-test |\n\n\n---\n\n# When to Use Do-While\n\nMost loops in C++ should be `for` or `while` loops. Pre-tested loops are the common case: read a file until it's empty, iterate over a vector, count from 1 to 10. All of those check the condition first and might run zero iterations.\n\nThe `do-while` loop fits three patterns where the body should run at least once before deciding whether to continue.\n\n### Pattern 1: Input Validation\n\nThe most common use of `do-while` is prompting a user for input, checking if it's valid, and reprompting if it isn't. The first prompt is unconditional, so a `do-while` reads naturally.\n\n\n```cpp\n#include \n\nint main() {\n int quantity{0};\n\n do {\n std::cout << \"Enter cart quantity (1-10): \";\n std::cin >> quantity;\n } while (quantity < 1 || quantity > 10);\n\n std::cout << \"Added \" << quantity << \" item(s) to your cart.\" << std::endl;\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\nEnter cart quantity (1-10): 0\nEnter cart quantity (1-10): 15\nEnter cart quantity (1-10): 3\nAdded 3 item(s) to your cart.\n```\n\n\nThe body always runs once because you have to ask the user before you know whether they typed something valid. After each entry, the condition checks whether the value is out of range. If it is, the loop runs the body again and asks once more.\n\nWriting the same thing with a `while` loop is awkward. You either have to prompt outside the loop and then again inside (duplicating the prompt), or initialize `quantity` to a known-bad value (like `-1`) just to force the first check to fail. Both feel like workarounds for the loop choice.\n\n\n> **INFO**\n>\n> **Cost:** The cost here is not CPU, it's clarity. `do-while` removes the need for a sentinel initial value or a duplicated prompt before the loop. Use it when the first iteration is unconditional by the problem itself.\n\n\n### Pattern 2: Menu Loops\n\nA menu loop shows options to a user, accepts a choice, takes action, and repeats until they pick \"exit\". You always want to show the menu at least once, so the body needs to run before the exit check.\n\n\n```cpp\n#include \n\nint main() {\n int choice{0};\n\n do {\n std::cout << \"\\n--- Shop Menu ---\\n\";\n std::cout << \"1. View cart\\n\";\n std::cout << \"2. Add product\\n\";\n std::cout << \"3. Checkout\\n\";\n std::cout << \"4. Exit\\n\";\n std::cout << \"Choose: \";\n std::cin >> choice;\n\n switch (choice) {\n case 1: std::cout << \"Cart: 3 items\\n\"; break;\n case 2: std::cout << \"Product added\\n\"; break;\n case 3: std::cout << \"Checkout complete\\n\"; break;\n case 4: std::cout << \"Goodbye\\n\"; break;\n default: std::cout << \"Invalid choice\\n\"; break;\n }\n } while (choice != 4);\n\n return 0;\n}\n```\n\n\n**Sample run:**\n\n\n```shell\n--- Shop Menu ---\n1. View cart\n2. Add product\n3. Checkout\n4. Exit\nChoose: 1\nCart: 3 items\n\n--- Shop Menu ---\n1. View cart\n2. Add product\n3. Checkout\n4. Exit\nChoose: 4\nGoodbye\n```\n\n\n`choice` is `0` at the start, which means a `while (choice != 4)` would have entered the body anyway, but the intent is clearer with `do-while`. You're saying \"show the menu, take a choice, repeat unless they picked exit,\" which matches the structure exactly.\n\n### Pattern 3: Retry-Then-Test\n\nSome operations have a built-in \"try first, then decide whether to try again\" shape. Connecting to a service, validating a payment, anything that could fail and needs a couple of attempts before giving up. The first attempt is unconditional, so the body should run once before the loop checks whether to repeat.\n\n\n```cpp\n#include \n\nbool tryCheckout(int attempt) {\n // Simulated: succeeds on the 3rd attempt\n std::cout << \"Checkout attempt \" << attempt << \"... \";\n if (attempt == 3) {\n std::cout << \"success\\n\";\n return true;\n }\n std::cout << \"failed\\n\";\n return false;\n}\n\nint main() {\n int attempt{0};\n bool success{false};\n const int maxAttempts{3};\n\n do {\n attempt++;\n success = tryCheckout(attempt);\n } while (!success && attempt < maxAttempts);\n\n if (success) {\n std::cout << \"Order placed after \" << attempt << \" attempt(s).\" << std::endl;\n } else {\n std::cout << \"Checkout failed after \" << maxAttempts << \" attempts.\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nYou don't know whether the first attempt will succeed until you actually try it, so the body must run at least once. The condition combines two checks: keep going while we haven't succeeded yet AND we haven't burned all our attempts. As soon as either is true, the loop ends.\n\n---\n\n# Why It's Used Less Than While and For\n\n`do-while` shows up rarely in C++ code compared to `for` and `while`. There's a reason for that. Most loops are pre-tested by nature: you check a condition first to decide whether you should do anything at all. Iterating over a container, counting from a start to an end, reading until end-of-file, processing while a queue has elements. In every one of those, zero iterations is a valid answer if the data isn't there.\n\n`do-while` only fits when at least one iteration is required by the problem itself. That's a narrower set of cases. The C++ Core Guidelines and most internal style guides don't ban `do-while`, but they note that any `do-while` can be rewritten as a `while` by either duplicating the body's first action or initializing a flag, and that rewrite is often easier to read for someone new to the code.\n\nThat said, when the situation genuinely calls for \"do, then check,\" `do-while` is the clearest way to write it. Input validation and menu loops are the two places where most experienced C++ programmers reach for it without hesitation.\n\nA small tour of common idioms in real code:\n\n\n```cpp\n// Idiom 1: input until valid\nint input{0};\ndo {\n std::cout << \"Enter a positive number: \";\n std::cin >> input;\n} while (input <= 0);\n\n// Idiom 2: menu loop\nchar option{};\ndo {\n showMenu();\n std::cin >> option;\n handle(option);\n} while (option != 'q');\n\n// Idiom 3: retry with attempt counter\nint attempt{0};\nbool ok{false};\ndo {\n ok = tryOperation();\n attempt++;\n} while (!ok && attempt < 5);\n```\n\n\nAll three share the same shape: do the thing, then check whether to do it again. Whenever you see that shape, `do-while` is the right tool.\n\n---\n\n# Break and Continue Work the Same Way\n\nInside a `do-while` loop, `break` and `continue` behave just like they do in `for` and `while`. `break` exits the loop immediately, skipping the bottom check. `continue` jumps to the bottom check (where the condition is evaluated) without running the rest of the body.\n\n\n```cpp\n#include \n\nint main() {\n int choice{0};\n\n do {\n std::cout << \"Pick 1-5 (or 0 to quit): \";\n std::cin >> choice;\n\n if (choice == 0) {\n break; // exit the loop right away\n }\n if (choice < 1 || choice > 5) {\n std::cout << \"Invalid, try again\\n\";\n continue; // jump to the condition check\n }\n\n std::cout << \"You picked: \" << choice << std::endl;\n } while (true);\n\n std::cout << \"Bye\" << std::endl;\n return 0;\n}\n```\n\n\n`while (true)` looks unusual but it's a common pattern: an infinite loop that exits only through `break` inside the body. The `continue` skips the rest of the body and goes straight to the bottom of the loop, where the condition is checked. Both keywords work in `do-while` exactly as they do elsewhere.\n\n---\n\n# A Few Common Mistakes\n\nA few specific failure modes show up often when people first use `do-while`. Spotting them quickly is worth a paragraph each.\n\n**Forgetting the semicolon.** Already covered above, but worth repeating: `while (cond);` ends with a semicolon. The compiler error usually points at the next line.\n\n**Putting a semicolon in the wrong place.** A different version of the same problem:\n\n\n```cpp\ndo; while (count < 3); // empty body, infinite loop if count never changes\n```\n\n\nThat `do;` is a `do` followed by an empty statement, followed by `while (count < 3);`. It compiles. It runs forever if `count` doesn't change. The fix is to use braces around a real body.\n\n**Off-by-one on the exit condition.** Because the check is at the bottom, the variable's value at exit may differ from what you'd expect with a `while`. Walk through a small example by hand if you're not sure.\n\n**Assuming `do-while` is faster.** It isn't. The body runs once unconditionally, but past that, both loops compile to nearly identical machine code. Pick the loop that reads clearly for the problem, not for imagined performance.","pageType":"cpp"}

Do-While Loop

Get Premium