C++ Loop Types

C++ Loop Types

Loops are control flow structures that allow you to execute a block of code repeatedly. This is essential when you need to perform the same operation multiple times, for example, processing each element in a collection or repeating an action until a certain condition is met.

Without loops, code would execute sequentially, statement by statement. Loops alter this flow, enabling repetition based on specified conditions.

A typical loop involves:

• Initialization: Setting up any variables needed for the loop (e.g., a counter).
• Condition: An expression evaluated before (or sometimes after) each iteration. If true, the loop body executes; if false, the loop terminates.
• Loop Body: The block of code that is executed repeatedly.
• Update: An operation performed after each iteration, often modifying variables involved in the condition (e.g., incrementing a counter).

C++ provides several types of loops:

Loop Type	Description
while loop	Repeats a block of code as long as a given condition is true. The condition is tested before each iteration. If the condition is initially false, the loop body never executes.
for loop	A compact loop structure typically used when the number of iterations is known or can be determined beforehand. It explicitly includes initialization, condition, and update expressions in its header.
do...while loop	Similar to while, but the condition is tested after the loop body executes. This guarantees the loop body runs at least once, even if the condition is initially false.
Range-based for loop (C++11)	Provides a simplified syntax for iterating over all elements in a range, such as standard containers (std::vector, std::array), C-style arrays, or initializer lists. This is often the preferred loop type for iterating over collections in modern C++.
Nested loops	You can place one loop inside another (e.g., a for loop inside a while loop). This is common for tasks like processing multi-dimensional data structures.

Loop Control Statements:

Loop control statements allow you to alter the normal execution flow within a loop:

Control Statement	Description
break statement	Immediately terminates the innermost loop (while, for, do...while) or switch statement it is contained within. Execution transfers to the statement immediately following the terminated loop/switch.
continue statement	Skips the rest of the current iteration of the innermost loop (while, for, do...while) and proceeds directly to the next iteration’s condition check (and update step for for loops).
goto statement	Transfers control unconditionally to a labeled statement within the same function. Use of goto is strongly discouraged in modern C++ as it makes code difficult to read, understand, and maintain. Structured control flow (loops, conditionals, functions) is almost always a better alternative.

Example: break and continue

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, -2, 3, 0, 5, -6, 7};

    std::cout << "Processing numbers:" << std::endl;
    for (int num : numbers) {
        if (num < 0) {
            std::cout << "  (Skipping negative number: " << num << ")" << std::endl;
            continue; // Skip to the next number
        }
        if (num == 0) {
            std::cout << "  (Encountered zero, stopping loop)" << std::endl;
            break; // Exit the loop entirely
        }
        // This part only executes for positive non-zero numbers before a zero is found
        std::cout << "  Processing positive number: " << num << std::endl;
    }

    std::cout << "Loop finished." << std::endl;
    return 0;
}

Output:

Processing numbers:
  Processing positive number: 1
  (Skipping negative number: -2)
  Processing positive number: 3
  (Encountered zero, stopping loop)
Loop finished.

The Infinite Loop:

An infinite loop is a loop whose condition never becomes false, causing it to run forever (or until manually interrupted). While sometimes intentional (e.g., in embedded systems or server processes waiting for input), they are often bugs.

Common ways to create (often accidentally) infinite loops:

• while(true): Explicitly always true condition.
• for(;;): Omitting all three parts of the for loop header creates an infinite loop.
• Logic Error: Forgetting to update the loop variable within a while or do...while loop, so the condition never changes.

// Example of an intentional infinite loop structure
// (often used in event loops or server main loops)
#include <iostream>

int main() {
    std::cout << "Entering infinite loop (Press Ctrl+C to exit)..." << std::endl;
    for (;;) { // Or while(true)
        // Perform some repeating task, e.g., check for network connections
        // Usually includes a way to break or exit under certain conditions
        // Or relies on external termination (like Ctrl+C)
    }

    // This line is never reached in this simple example
    std::cout << "Loop exited (should not happen here)." << std::endl;
    return 0;
}

Note: You can typically terminate an infinite loop running in your console by pressing Ctrl + C.