For Loop

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.

​

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.

* **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)

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

{
    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
    }
}

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.

​

Temporary Lifetime Rules

• 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.