Цикл for по диапазону (начиная с C++11)

Выполняет цикл for по диапазону.

Используется как более удобочитаемый аналог традиционного цикла for, работающего с диапазоном значений, например со всеми элементами контейнера.

Синтаксис

Пояснение

Приведённый выше синтаксис создаёт код, эквивалентный следующему за исключением продления времени жизни временных объектов в range-initializer (см. ниже)(начиная с C++23) (переменные и выражения, заключённые в /* */, приведены только для наглядности):

range-initializer вычисляется для инициализации последовательности или диапазона, по которому выполняется итерация. Каждый элемент последовательности по очереди разыменовывается и используется для инициализации переменной с типом и именем, указанными в item-declaration.

item-declaration может быть одним из следующих вариантов:

• простое объявление со следующими ограничениями:
• Оно содержит только один декларатор.
• Декларатор не должен иметь инициализатора.
• Последовательность спецификаторов объявления может содержать только спецификаторы типа и constexpr и не может определять класс или перечисление.

Выражения, приведённые только для наглядности, /* begin-expr */ и /* end-expr */, определяются следующим образом:

• Если тип /* range */ является ссылкой на тип массива R:
• Если R имеет границу N, то /* begin-expr */ — это /* range */, а /* end-expr */ — это /* range */ + N.
• Если R является массивом неизвестной границы или массивом неполного типа, программа некорректна.
• Если тип /* range */ является ссылкой на тип класса C и поиск в области видимости C имён «begin» и «end» находит хотя бы по одному объявлению для каждого имени, то /* begin-expr */ — это /* range */.begin(), а /* end-expr */ — это /* range */.end().
• В противном случае /* begin-expr */ — это begin(/* range */), а /* end-expr */ — это end(/* range */), где «begin» и «end» находятся посредством поиска, зависящего от аргументов (обычный поиск без ADL не выполняется).

Если цикл необходимо завершить внутри statement, в качестве завершающего оператора можно использовать оператор break.

Если текущую итерацию необходимо завершить внутри statement, для этого можно использовать оператор continue.

Если имя, введённое в init-statement, повторно объявляется во внешнем блоке statement, программа некорректна:

for (int i : {1, 2, 3})
    int i = 1; // error: redeclaration

Временный объект в инициализаторе диапазона

Если range-initializer возвращает временный объект, время его жизни продлевается до конца цикла, что обеспечивается привязкой к универсальной ссылке /* range */.

Время жизни всех временных объектов внутри range-initializer не продлевается, если только в противном случае они не уничтожались бы в конце range-initializer(начиная с C++23).

// if foo() returns by value
for (auto& x : foo().items()) { /* ... */ } // until C++23 undefined behavior

for (T thing = foo(); auto& x : thing.items()) { /* ... */ } // OK

using T = std::list<int>;
const T& f1(const T& t) { return t; }
const T& f2(T t)        { return t; } // always returns a dangling reference
T g();

void foo()
{
    for (auto e : f1(g())) {} // OK: lifetime of return value of g() extended
    for (auto e : f2(g())) {} // UB: lifetime of f2's value parameter ends early
}

Примечания

Если range-initializer — это список инициализации в фигурных скобках, тип /* range */ выводится как ссылка на std::initializer_list.

В обобщённом коде безопасно и предпочтительно использовать вывод типа для универсальной ссылки, for (auto&& var : sequence).

Интерпретация через члены используется, если тип диапазона имеет член с именем «begin» и член с именем «end». Это применяется независимо от того, является ли член типом, членом-данными, функцией или перечислителем, а также независимо от его доступности. Поэтому такой класс, как class meow { enum { begin = 1, end = 2 }; /* rest of class */ };, нельзя использовать в цикле for по диапазону, даже если присутствуют функции «begin»/«end» в области видимости пространства имён.

Хотя переменная, объявленная в item-declaration, обычно используется в statement, это не является обязательным.

При использовании с (неконстантным) объектом, имеющим семантику копирования при записи, цикл for по диапазону может вызвать глубокое копирование, неявно вызывая неконстантную функцию-член begin().

struct cow_string { /* ... */ }; // a copy-on-write string
cow_string str = /* ... */;

// for (auto x : str) { /* ... */ } // may cause deep copy

for (auto x : std::as_const(str)) { /* ... */ }

Ключевые слова

for

Пример

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v = {0, 1, 2, 3, 4, 5};
    
    for (const int& i : v) // access by const reference
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (auto i : v) // access by value, the type of i is int
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (auto&& i : v) // access by forwarding reference, the type of i is int&
        std::cout << i << ' ';
    std::cout << '\n';
    
    const auto& cv = v;
    
    for (auto&& i : cv) // access by f-d reference, the type of i is const int&
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int n : {0, 1, 2, 3, 4, 5}) // the initializer may be a
                                     // braced-enclosed initializer list
        std::cout << n << ' ';
    std::cout << '\n';
    
    int a[] = {0, 1, 2, 3, 4, 5};
    for (int n : a) // the initializer may be an array
        std::cout << n << ' ';
    std::cout << '\n';
    
    for ([[maybe_unused]] int n : a)  
        std::cout << 1 << ' '; // the loop variable need not be used
    std::cout << '\n';
    
    for (auto n = v.size(); auto i : v) // the init-statement (C++20)
        std::cout << --n + i << ' ';
    std::cout << '\n';
    
    for (typedef decltype(v)::value_type elem_t; elem_t i : v)
    // typedef declaration as init-statement (C++20)
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (using elem_t = decltype(v)::value_type; elem_t i : v)
    // alias declaration as init-statement (C++23)
        std::cout << i << ' ';
    std::cout << '\n';
}

0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
1 1 1 1 1 1 
5 5 5 5 5 5 
0 1 2 3 4 5 
0 1 2 3 4 5

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были ретроактивно применены к ранее опубликованным стандартам C++.

См. также