structured bindings

Structured bindings — синтаксис объявления нескольких именованных переменных сразу из одного составного объекта: std::pair, std::tuple, обычного массива фиксированного размера, или struct/class с исключительно публичными нестатическими членами. Форма auto [a, b, c] = expr; вводит a, b, c как имена, ссылающиеся на элементы expr — по одному имени на элемент, в порядке их объявления.Structured bindings are syntax for declaring several named variables at once from a single compound object: std::pair, std::tuple, a fixed-size raw array, or a struct/class with exclusively public non-static members. The form auto [a, b, c] = expr; introduces a, b, c as names referring to the elements of expr — one name per element, in declaration order.

std::map<std::string, int>::iterator it = m.find("key");
if (it != m.end()) {
    const auto& key = it->first;
    int value = it->second;
}

// или для функций, возвращающих tuple:// or for functions returning a tuple:
int a; double b; std::string c;
std::tie(a, b, c) = make_tuple();  // все переменные объявлены заранее// every variable declared ahead of time

auto it = m.find("key");
if (auto [key, value] = *it; it != m.end()) {
    // key и value уже готовы, без ->first/->second// key and value are ready, no ->first/->second
}

auto [a, b, c] = make_tuple();  // одна строка, ничего не объявлено заранее// one line, nothing pre-declared

Составные возвращаемые значения были в языке давно, но всегда требовали многословного разбора:Compound return values had been in the language for a long time, but always required verbose unpacking:

Структурная привязка не создаёт a, b, c как независимые переменные — она сперва создаёт единственную скрытую переменную (назовём её e), инициализированную тем же выражением, а a, b, c — это просто имена-псевдонимы для элементов e. Поведение зависит от вида объекта:A structured binding doesn't create a, b, c as independent variables — it first creates a single hidden variable (call it e) initialized with the same expression, and a, b, c are just alias names for the elements of e. The behavior depends on the kind of object:

// для std::pair/std::tuple — вызывает get<0>(e), get<1>(e), ...:// for std::pair/std::tuple — calls get<0>(e), get<1>(e), ...:
auto [a, b] = std::make_pair(1, "x");
// концептуально эквивалентно:// conceptually equivalent to:
auto e = std::make_pair(1, "x");
auto& a = std::get<0>(e);
auto& b = std::get<1>(e);

// для struct с публичными членами — привязка к членам по порядку объявления:// for a struct with public members — binds to members in declaration order:
struct Point { int x, y; };
auto [px, py] = Point{1, 2};  // px псевдоним e.x, py псевдоним e.y// px aliases e.x, py aliases e.y

// для массива фиксированного размера — привязка к элементам напрямую:// for a fixed-size array — binds to elements directly:
int arr[2] = {10, 20};
auto [first, second] = arr;

Ключевое следствие скрытой переменной e: const auto& [a, b] = expr; продлевает время жизни временного объекта ровно так же, как обычное const auto& x = expr; — привязка к rvalue безопасна, пока жива скрытая e. Изменяемость тоже наследуется от e: auto [a, b] = pair; копирует, auto& [a, b] = pair; даёт изменяемые псевдонимы на исходный объект.The key consequence of the hidden e: const auto& [a, b] = expr; extends the lifetime of a temporary exactly the way an ordinary const auto& x = expr; would — binding to an rvalue is safe as long as the hidden e is alive. Mutability is likewise inherited from e: auto [a, b] = pair; copies, auto& [a, b] = pair; gives mutable aliases to the original object.

• cppreference — Structured binding declaration
• WG21 P0217 — Unpacking Declarations