For Loop

A for loop in C++ is a deterministic control flow statement that facilitates the repeated execution of a block of code. It consolidates initialization, condition evaluation, and iteration operations into a single structured header, managing the lifecycle of loop-control variables within a strictly defined block scope. C++ provides two distinct forms: the traditional for loop and the range-based for loop.

Traditional for Loop

for (init-statement condition_opt; expression_opt) {
    // Loop body
}

Component Breakdown

1. init-statement: Executed exactly once before the loop begins. By definition in the C++ grammar, this statement inherently includes its own trailing semicolon (e.g., int i = 0; or a null statement ;). Variables declared here possess block scope restricted entirely to the loop (encompassing the condition, iteration expression, and body). Multiple variables of the same base type can be declared using comma separation.
2. condition_opt: Evaluated before every iteration, including the first. This can be an expression that yields a value contextually convertible to bool, or it can be a declaration with a brace-or-equals initializer (e.g., auto* ptr = get_node()). If it is a declaration, the declared variable is contextually evaluated to bool. If the evaluation yields true, the loop body executes. If false, the loop terminates immediately. If omitted, it implicitly evaluates to true.
3. expression_opt: Evaluated at the end of each iteration, immediately after the loop body completes. It is strictly an expression (not a statement) and is typically used to mutate the loop-control variable.

Execution Flow

1. The init-statement executes.
2. The condition_opt is evaluated.
   • If false, the loop terminates.
   • If true, control proceeds to step 3.
3. The loop body executes.
4. The expression_opt executes.
5. Control flow returns to step 2.

Technical Nuances

• Infinite Loops: Because the condition is optional and defaults to true, omitting both the condition and the expression creates an infinite loop. The init-statement must still provide its semicolon.

for (;;)

* **Comma Operator**: The iteration expression can utilize the comma operator to perform multiple operations sequentially.
  ```cpp
for (int i = 0, j = 10; i < j; ++i, --j) {
    // Body
}

Range-Based for Loop (C++11 and later)

The range-based for loop provides a simplified syntax for iterating over a range, container, or any object that provides iterator semantics.

for (init-statement_opt range_declaration : range_expression) {
    // Loop body
}

Component Breakdown

1. init-statement_opt (C++20): An optional initialization statement (which includes its own semicolon) that executes before the range is evaluated. This is useful for scoping variables tightly to the loop without polluting the outer scope.
2. range_declaration: Declares a named variable whose type corresponds to the elements of the iterable sequence. This is frequently declared using auto, auto&, or const auto& to deduce the type and manage reference semantics.
3. range_expression: An expression that evaluates to an iterable sequence. This can be a brace-init-list, a raw array, or a type supporting iterator retrieval.

Under the Hood

The compiler internally expands the range-based for loop into a traditional loop utilizing iterators. Conceptually, it translates to the following block:

{
    init-statement_opt // If present (C++20)
    auto&& __range = range_expression;
    auto __begin = begin_expr;
    auto __end = end_expr;
    for ( ; __begin != __end; ++__begin) {
        range_declaration = *__begin;
        // Loop body
    }
}

Iterator Resolution (begin_expr and end_expr): A common misconception is that the compiler explicitly calls std::begin() and std::end(). In reality, the compiler resolves the iterators using the following strict sequence:

1. Raw Arrays: If __range is a raw array, begin_expr is __range and end_expr is __range + bound.
2. Member Functions: If __range is a class type possessing .begin() and .end() member functions, it uses __range.begin() and __range.end().
3. Argument-Dependent Lookup (ADL): Otherwise, it uses unqualified calls to begin(__range) and end(__range). These are resolved via ADL based on the namespace of the __range type.

C++17 Iterator/Sentinel Separation: Notice that __begin and __end are declared as separate auto statements. Prior to C++17, they were declared in a single statement (auto __begin = begin_expr, __end = end_expr;), which forced them to be the exact same type. C++17 separated these declarations to allow the end iterator (the sentinel) to be a different type than the begin iterator, a foundational requirement for C++20 Ranges.

Temporary Lifetime Rules

A critical technical nuance of the range-based for loop involves the lifetime of temporaries generated within the range_expression.

• Pre-C++23 (The Dangling Temporary Issue): Historically, only the lifetime of the final object returned by the range_expression was extended to the end of the loop (bound to __range). If the range_expression contained intermediate temporaries (e.g., for (auto x : get_container().get_view()) where get_container() returns a temporary by value), those intermediate temporaries would be destroyed at the end of the full expression, leaving the __range reference dangling before the loop body even began.
• C++23 Lifetime Extension: C++23 fixed this hazard by extending the lifetime of all temporaries materialized within the range_expression. Any temporary created during the evaluation of the range expression is now kept alive until the end of the entire loop block, ensuring safe iteration over chained views and accessors.

Master C++ with Deep Grasping Methodology!

Learn More