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

Files changed (1) hide show

tmp/tmp69m_pg9p/{from.md → to.md} +23 -23

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

@@ -1,16 +1,16 @@
 ## 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 ';'
 ```
@@ -32,11 +32,11 @@ from the corresponding structured binding declaration. The type of the
 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`.
 [*Note 2*: The top-level cv-qualifiers of `T` are cv. — *end note*]
 [*Example 1*:
@@ -52,18 +52,17 @@ auto& [ xr, yr ] = f();         // xr and yr refer to elements in the array refe
 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
@@ -84,23 +83,24 @@ 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
-struct S { int x1 : 2; volatile double y1; };
 S f();
 const auto [ x, y ] = f();
 ```
-The type of the *id-expression* `x` is “`const int`”, the type of the
 *id-expression* `y` is “`const volatile double`”.
 — *end example*]

 ## 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 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 *cv1* `A` and no *ref-qualifier* is
+present, *`e`* is defined by
 ``` bnf
 attribute-specifier-seqₒₚₜ *S* cv 'A' 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 `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`.
 [*Note 2*: The top-level cv-qualifiers of `T` are cv. — *end note*]
 [*Example 1*:
 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ᵢ`. 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*.
 [*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
 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 that of `e.mᵢ`
+[[expr.ref]]; the referenced type is the declared type of `mᵢ` if that
+type is a reference type, or the type of `e.mᵢ` otherwise. The lvalue is
+a bit-field if that member is a bit-field.
 [*Example 2*:
 ``` cpp
+struct S { mutable int x1 : 2; volatile double y1; };
 S f();
 const auto [ x, y ] = f();
 ```
+The type of the *id-expression* `x` is “`int`”, the type of the
 *id-expression* `y` is “`const volatile double`”.
 — *end example*]

Diff to HTML by rtfpessoa