[dcl.struct.bind] - C++17 → C++20

Files changed (1) hide show

tmp/tmpzp_flrq1/{from.md → to.md} +57 -37

tmp/tmpzp_flrq1/{from.md → to.md} RENAMED Viewed

@@ -1,29 +1,38 @@
 ## Structured binding declarations <a id="dcl.struct.bind">[[dcl.struct.bind]]</a>
-A structured binding declaration introduces the *identifier*s `v`₀,
-`v`₁, `v`₂, ... of the *identifier-list* as names (
-[[basic.scope.declarative]]), called *structured binding*s. Let cv
-denote the *cv-qualifier*s in the *decl-specifier-seq*. First, a
-variable with a unique name `e` is introduced. If the
 *assignment-expression* in the *initializer* has array type `A` and no
-*ref-qualifier* is present, `e` has type cv `A` 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
 ``` bnf
-attribute-specifier-seqₒₚₜ decl-specifier-seq ref-qualifierₒₚₜ 'e' initializer ';'
 ```
 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`.
-[*Note 1*: `E` is never a reference type (Clause
-[[expr]]). — *end note*]
 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 `v`ᵢ 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`.
@@ -39,38 +48,49 @@ array and whose type is `T`; the referenced type is `T`.
 ```
 — *end example*]
 Otherwise, if the *qualified-id* `std::tuple_size<E>` names a complete
-type, 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. The
-*unqualified-id* `get` is looked up in the scope of `E` by class member
-access lookup ([[basic.lookup.classref]]), and if that finds at least
-one declaration, the initializer is `e.get<i>()`. Otherwise, the
-initializer is `get<i>(e)`, where `get` is looked up in the associated
-namespaces ([[basic.lookup.argdep]]). In either case, `get<i>` is
-interpreted as a *template-id*.
-[*Note 3*: Ordinary unqualified lookup ([[basic.lookup.unqual]]) is
-not performed. — *end note*]
-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 `Tᵢ` designated
-by `std::tuple_element<i, E>::type`, each `v`ᵢ is a variable of type
-“reference to `Tᵢ`” initialized with the initializer, where the
-reference is an lvalue reference if the initializer is an lvalue and an
-rvalue reference otherwise; the referenced type is `Tᵢ`.
-Otherwise, all of `E`’s non-static data members shall be public direct
-members of `E` or of the same unambiguous public base class of `E`, `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 `m`₀,
-`m`₁, `m`₂, ... (in declaration order), each `v`ᵢ is the name of an
-lvalue that refers to the member `m`ᵢ of `e` and whose type is cv `Tᵢ`,
-where `Tᵢ` is the declared type of that member; the referenced type is
 cv `Tᵢ`. The lvalue is a bit-field if that member is a bit-field.
 [*Example 2*:
 ``` cpp

 ## Structured binding declarations <a id="dcl.struct.bind">[[dcl.struct.bind]]</a>
+A structured binding declaration introduces the *identifier*s `v₀`,
+`v₁`, `v₂`, … of the *identifier-list* as names
+[[basic.scope.declarative]] of *structured binding*s. Let cv denote the
+*cv-qualifier*s in the *decl-specifier-seq* and *S* consist of the
+*storage-class-specifier*s 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 `A` and no
+*ref-qualifier* is present, *`e`* is defined by
 ``` bnf
+attribute-specifier-seqₒₚₜ *S* cv 'A' e ';'
+```
+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
+``` bnf
+attribute-specifier-seqₒₚₜ decl-specifier-seq ref-qualifierₒₚₜ e initializer ';'
 ```
 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`.
+[*Note 1*: `E` is never a reference type [[expr.prop]]. — *end note*]
+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 `v`ᵢ 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`.
 ```
 — *end example*]
 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 `v`_`i`. The *unqualified-id* `get`
+is looked up in the scope of `E` by class member access lookup
+[[basic.lookup.classref]], and if that 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` is looked up in the associated namespaces
+[[basic.lookup.argdep]]. In either case, `get<i>` is interpreted as a
+*template-id*.
+[*Note 3*: Ordinary unqualified lookup [[basic.lookup.unqual]] is not
+performed. — *end note*]
+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 `Tᵢ` designated
+by `std::tuple_element<i, E>::type` and the type `Uᵢ` designated by
+either `Tᵢ&` or `Tᵢ&&`, where `Uᵢ` is an lvalue reference if the
+initializer is an lvalue and an rvalue reference otherwise, variables
+are introduced with unique names `rᵢ` as follows:
+``` bnf
+*S* 'Uᵢ rᵢ =' initializer ';'
+```
+Each `vᵢ` is the name of an lvalue of type `Tᵢ` that refers to the
+object bound to `rᵢ`; the referenced type is `Tᵢ`.
+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 `m₀`,
+`m₁`, `m₂`, … (in declaration order), each `v`ᵢ is the name of an lvalue
+that refers to the member `m`ᵢ of *`e`* and whose type is cv `Tᵢ`, where
+`Tᵢ` is the declared type of that member; the referenced type is
 cv `Tᵢ`. The lvalue is a bit-field if that member is a bit-field.
 [*Example 2*:
 ``` cpp

Diff to HTML by rtfpessoa