9 Declarations [dcl.dcl]

A structured binding declaration introduces the identifiers ${\text{v}}_0$, ${\text{v}}_1$, ${\text{v}}_2,\dots$ of the identifier-list as names of structured bindings.

Let cv denote the cv-qualifiers in the decl-specifier-seq and S consist of the storage-class-specifiers of the decl-specifier-seq (if any).

A cv that includes volatile is deprecated; see [depr.volatile.type].

First, a variable with a unique name e is introduced.

If the assignment-expression in the initializer has array type cv1 A and no ref-qualifier is present, e is defined by and each element is copy-initialized or direct-initialized from the corresponding element of the assignment-expression as specified by the form of the initializer.

Otherwise, e is defined as-if by where the declaration is never interpreted as a function declaration and the parts of the declaration other than the declarator-id are taken from the corresponding structured binding declaration.

The type of the id-expression e is called E.

If the initializer refers to one of the names introduced by the structured binding declaration, the program is ill-formed.

If E is an array type with element type T, the number of elements in the identifier-list shall be equal to the number of elements of E.

Each ${\text{v}}_i$ is the name of an lvalue that refers to the element i of the array and whose type is T; the referenced type is T.

Otherwise, if the qualified-id std​::​tuple_size<E> names a complete class type with a member named value, the expression std​::​tuple_size<E>​::​value shall be a well-formed integral constant expression and the number of elements in the identifier-list shall be equal to the value of that expression.

Let i be an index prvalue of type std​::​size_t corresponding to ${\text{v}}_i$.

If a search for the name get in the scope of E ([class.member.lookup]) finds at least one declaration that is a function template whose first template parameter is a non-type parameter, the initializer is e.get<i>().

Otherwise, the initializer is get<i>(e), where get undergoes argument-dependent lookup ([basic.lookup.argdep]).

In either case, get<i> is interpreted as a template-id.

In either case, e is an lvalue if the type of the entity e is an lvalue reference and an xvalue otherwise.

Given the type ${\text{T}}_i$ designated by std​::​tuple_element<i, E>​::​type and the type ${\text{U}}_i$ designated by either ${\text{T}}_i$& or ${\text{T}}_i$&&, where ${\text{U}}_i$ is an lvalue reference if the initializer is an lvalue and an rvalue reference otherwise, variables are introduced with unique names ${\text{r}}_i$ as follows:

Each ${\text{v}}_i$ is the name of an lvalue of type ${\text{T}}_i$ that refers to the object bound to ${\text{r}}_i$; the referenced type is ${\text{T}}_i$.

Otherwise, all of E's non-static data members shall be direct members of E or of the same base class of E, well-formed when named as e.name in the context of the structured binding, E shall not have an anonymous union member, and the number of elements in the identifier-list shall be equal to the number of non-static data members of E.

Designating the non-static data members of E as ${\text{m}}_0$, ${\text{m}}_1$, ${\text{m}}_2,\dots$ (in declaration order), each ${\text{v}}_i$ is the name of an lvalue that refers to the member m${}_i$ of e and whose type is that of e.${\text{m}}_i$ ([expr.ref]); the referenced type is the declared type of ${\text{m}}_i$ if that type is a reference type, or the type of e.${\text{m}}_i$ otherwise.

The lvalue is a bit-field if that member is a bit-field.