# `for` loop

From cppreference.com
< cpp‎ | language

Conditionally executes a statement repeatedly, where the statement does not need to manage the loop condition.

### Syntax

attr﻿(optional) `for (` init-statement condition﻿(optional) `;` expression﻿(optional) `)` statement |  |

attr | - | (since C++11) any number of attributes

init-statement

-

one of

- an expression statement (which may be a null statement ;)
- a simple declaration (typically a declaration of a loop counter variable with initializer), it may declare arbitrary many variables or structured bindings (since C++17)

- an alias declaration

(since C++23)

Note that any init-statement must end with a semicolon. This is why it is often described informally as an expression or a declaration followed by a semicolon.

condition | - | a condition
expression | - | an expression (typically an expression that increments the loop counter)
statement | - | a statement (typically a compound statement)

### Condition

A condition can either be an expression or a simple declaration.

- If it can be syntactically resolved as a structured binding declaration, it is interpreted as a structured binding declaration.

(since C++26)

- If it can be syntactically resolved as an expression, it is treated as an expression. Otherwise, it is treated as a declaration that is not a structured binding declaration(since C++26).

When control reaches condition, the condition will yield a value, which is used to determine whether statement will be executed.

#### Expression

If condition is an expression, the value it yields is the the value of the expression contextually converted to bool. If that conversion is ill-formed, the program is ill-formed.

#### Declaration

If condition is a simple declaration, the value it yields is the value of the decision variable (see below) contextually converted to bool. If that conversion is ill-formed, the program is ill-formed.

##### Non-structured binding declaration

The declaration has the following restrictions:

- Syntactically conforms to the following form:

  - type-specifier-seq declarator `=` assignment-expression

(until C++11)

  - attribute-specifier-seq(optional) decl-specifier-seq declarator brace-or-equal-initializer

(since C++11)

- The declarator cannot specify a function or an array.
- The type specifier sequence (until C++11) declaration specifier sequence can only contain type specifiers and constexpr, and it(since C++11) cannot define a class or enumeration.

The decision variable of the declaration is the declared variable.

##### Structured binding declaration

The declaration has the following restrictions:

- The expression in its initializer cannot be of an array type.
- The declaration specifier sequence can only contain type specifiers and constexpr.

The decision variable of the declaration is the invented variable e introduced by the declaration.

(since C++26)

### Explanation

A for statement equivalent to:

`{`

  init-statement
  `while (` condition `)`
  `{`
    statement
    expression `;`
  `}`

`}`

Except that

- The scope of init-statement and the scope of condition are the same.
- The scope of statement and the scope of expression are disjoint and nested within the scope of init-statement and condition.
- Executing a continue statement in statement will evaluate expression.
- Empty condition is equivalent to true.

If the loop needs to be terminated within statement, a break statement can be used as terminating statement.

If the current iteration needs to be terminated within statement, a continue statement can be used as shortcut.

### Notes

As is the case with `while` loop, if statement is not a compound statement, the scope of variables declared in it is limited to the loop body as if it was a compound statement.

    for (;;)
        int n;
    // n goes out of scope

As part of the C++ forward progress guarantee, the behavior is undefined if a loop that is not a trivial infinite loop (since C++26) without observable behavior does not terminate. Compilers are permitted to remove such loops.

While in C names declared in the scope of init-statement and condition can be shadowed in the scope of statement, it is forbidden in C++:

    for (int i = 0;;)
    {
        long i = 1;   // valid C, invalid C++
        // ...
    }

### Keywords

`for`

### Example

Run this code

    #include <iostream>
    #include <vector>

    int main()
    {
        std::cout << "1) typical loop with a single statement as the body:\n";
        for (int i = 0; i < 10; ++i)
            std::cout << i << ' ';

        std::cout << "\n\n" "2) init-statement can declare multiple names, as\n"
                     "long as they can use the same decl-specifier-seq:\n";
        for (int i = 0, *p = &i; i < 9; i += 2)
            std::cout << i << ':' << *p << ' ';

        std::cout << "\n\n" "3) condition may be a declaration:\n";
        char cstr[] = "Hello";
        for (int n = 0; char c = cstr[n]; ++n)
            std::cout << c;

        std::cout << "\n\n" "4) init-statement can use the auto type specifier:\n";
        std::vector<int> v = {3, 1, 4, 1, 5, 9};
        for (auto iter = v.begin(); iter != v.end(); ++iter)
            std::cout << *iter << ' ';

        std::cout << "\n\n" "5) init-statement can be an expression:\n";
        int n = 0;
        for (std::cout << "Loop start\n";
             std::cout << "Loop test\n";
             std::cout << "Iteration " << ++n << '\n')
        {
            if (n > 1)
                break;
        }

        std::cout << "\n" "6) constructors and destructors of objects created\n"
                     "in the loop's body are called per each iteration:\n";
        struct S
        {
            S(int x, int y) { std::cout << "S::S(" << x << ", " << y << "); "; }
            ~S() { std::cout << "S::~S()\n"; }
        };
        for (int i{0}, j{5}; i < j; ++i, --j)
            S s{i, j};

        std::cout << "\n" "7) init-statement can use structured bindings:\n";
        long arr[]{1, 3, 7};
        for (auto [i, j, k] = arr; i + j < k; ++i)
            std::cout << i + j << ' ';
        std::cout << '\n';
    }

Output:

    1) typical loop with a single statement as the body:
    0 1 2 3 4 5 6 7 8 9

    2) init-statement can declare multiple names, as
    long as they can use the same decl-specifier-seq:
    0:0 2:2 4:4 6:6 8:8

    3) condition may be a declaration:
    Hello

    4) init-statement can use the auto type specifier:
    3 1 4 1 5 9

    5) init-statement can be an expression:
    Loop start
    Loop test
    Iteration 1
    Loop test
    Iteration 2
    Loop test

    6) constructors and destructors of objects created
    in the loop's body are called per each iteration:
    S::S(0, 5); S::~S()
    S::S(1, 4); S::~S()
    S::S(2, 3); S::~S()

    7) init-statement can use structured bindings:
    4 5 6

### See also

range-`for` loop (C++11) | executes loop over range
C documentation for for

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/language/for&oldid=173814"