> ## 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.
# C++ 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
```cpp theme={"dark"}
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.
```cpp theme={"dark"}
```
for (;;) {
// Infinite loop
}
````
* **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.
```cpp theme={"dark"}
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:
```cpp theme={"dark"}
{
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.
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
