Loops in C++ (for, while, do-while)

A loop in C++ is a control structure that repeatedly executes a block of code as long as a specified condition remains true, allowing a program to perform repetitive tasks efficiently without duplicating code. C++ provides three primary loop constructs — 'for', 'while', and 'do-while' — each suited to different scenarios depending on whether the number of iterations is known in advance and whether the loop body must execute at least once.

Imagine washing 50 dishes one by one — instead of writing 'wash dish' 50 separate times, you'd just say 'keep washing dishes until there are none left.' That's exactly what a loop does in code: it repeats an action until a condition is no longer true, saving you from writing the same instructions over and over. A 'for' loop is best when you know exactly how many times to repeat something (like counting 1 to 10), a 'while' loop is best when you don't know the exact count but know the stopping condition (like reading input until the user types 'quit'), and a 'do-while' loop guarantees the code runs at least once before checking the condition.

Instagram's infinite scroll feed uses loop-like logic to keep fetching and displaying new posts as long as the user keeps scrolling (a while-like condition). A point-of-sale system at a grocery store uses a for loop to iterate through every item in a shopping cart to calculate the total bill. A password login prompt commonly uses a do-while loop, since the user must be asked for their password at least once before the program checks if it's correct, then loops again only if it's wrong. Video games use loops extensively in their 'game loop' — a continuously running while loop that keeps updating the screen, checking input, and rendering graphics 60+ times per second until the player exits the game.

Without loops, performing any repetitive task — processing every item in a list, validating user input until it's correct, or running a simulation for thousands of steps — would require manually writing out the same code again and again, which is impractical, error-prone, and impossible for tasks with a variable or very large number of repetitions. Loops let programs handle repetition dynamically and efficiently, forming the foundation of algorithms that process arrays, search data, sort collections, and run continuously (like game engines and servers).

• for Loop: Ideal when the number of iterations is known beforehand; combines initialization, condition-checking, and increment/decrement into a single compact line, commonly used for iterating a fixed number of times or traversing arrays and containers by index.
• while Loop: Checks its condition before each iteration (entry-controlled loop), executing the loop body only as long as the condition remains true; used when the number of iterations isn't known in advance and depends on dynamic runtime conditions.
• do-while Loop: Checks its condition after executing the loop body (exit-controlled loop), guaranteeing the code runs at least once regardless of the condition; commonly used for input validation and menu-driven programs where the action must happen before checking whether to repeat.
• Range-Based for Loop (C++11+): A modern, simplified for-loop syntax introduced in C++11 that directly iterates over each element of a container (like an array or vector) without needing explicit index management, improving readability and reducing off-by-one errors.
• Nested Loops: A loop placed inside another loop, where the inner loop completes all of its iterations for each single iteration of the outer loop; commonly used for working with 2D data structures like matrices or grids, and for generating patterns.

• Creating an Infinite Loop by Forgetting to Update the Condition Variable: Writing 'while (i < 10) { cout << i; }' without incrementing 'i' inside the loop body causes the condition to remain true forever, freezing or crashing the program. Always ensure the loop's controlling variable is modified somewhere inside the loop body so the condition can eventually become false.
• Off-by-One Errors in Loop Boundaries: Using '<=' when '<' was intended (or vice versa) causes a loop to execute one time too many or too few — for example, 'for (int i = 0; i <= arraySize; i++)' accessing 'array[i]' will go one index past the array's valid bounds when 'i' equals 'arraySize', causing undefined behavior or a crash.
• Using a for Loop When a while Loop Is More Appropriate (or Vice Versa): Forcing a for loop's compact syntax onto a situation where the number of iterations is genuinely unknown (like reading input until a sentinel value) leads to awkward, hard-to-read code with an empty condition or update clause. Choose the loop type that naturally matches whether the iteration count is known in advance.
• Modifying the Loop Control Variable Inside the Loop Body Unexpectedly: Manually changing the value of the loop counter inside a for loop's body (in addition to its automatic update) can cause the loop to skip iterations, repeat unexpectedly, or run for an incorrect number of cycles, making the code's behavior confusing and error-prone for anyone reading it later.
• Forgetting the Semicolon After a do-while Loop's Condition: Unlike for and while loops, a do-while loop's closing 'while (condition)' must be followed by a semicolon ';' — omitting it is a common syntax error for developers switching between loop types, since it's easy to forget this one structural difference.

• Choose the Loop Type That Matches the Problem's Natural Structure: Use a 'for' loop when the iteration count is known in advance (like iterating a fixed range or array), a 'while' loop when the stopping condition is dynamic and unknown ahead of time, and a 'do-while' loop specifically when the body must execute at least once regardless of the condition (like input prompts).
• Prefer Range-Based for Loops When Simply Iterating Over a Container: When you just need to access each element of an array, vector, or other container without needing the index itself, use 'for (auto& element : container)' instead of manual index-based loops — it's more readable, less error-prone (no off-by-one risk), and clearly communicates intent.
• Always Ensure the Loop Has a Clear, Reachable Exit Condition: Before writing a loop, mentally trace through how the controlling condition will eventually become false. For while/do-while loops especially, double-check that every code path inside the loop body properly updates the condition variable to avoid accidental infinite loops.
• Use break and continue Judiciously, Not as a Crutch for Poor Loop Design: 'break' (exits the loop entirely) and 'continue' (skips to the next iteration) are useful for handling exceptional cases within a loop, but overusing them to patch overly complex loop conditions can make code harder to follow — consider restructuring the loop's condition or logic first if you find yourself relying on many scattered break/continue statements.

Loops — for, while, and do-while — allow C++ programs to repeat blocks of code efficiently without duplicating instructions, forming the foundation for processing collections, validating input, and building responsive, repetitive systems like game loops and menu-driven applications. Choosing the correct loop type based on whether the iteration count is known in advance (for) or depends on a dynamic condition (while/do-while), while carefully avoiding classic pitfalls like infinite loops and off-by-one errors, is a core skill every C++ programmer must master before moving on to arrays, functions, and more advanced algorithms.