[dcl.init.aggr] - C++17 → C++20

Files changed (1) hide show

tmp/tmpl55ewl3w/{from.md → to.md} +160 -99

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

@@ -1,41 +1,74 @@
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
-An *aggregate* is an array or a class (Clause  [[class]]) with
-- no user-provided, `explicit`, or inherited constructors (
-  [[class.ctor]]),
-- no private or protected non-static data members (Clause
- [[class.access]]),
-- no virtual functions ([[class.virtual]]), and
-- no virtual, private, or protected base classes ([[class.mi]]).
 [*Note 1*: Aggregate initialization does not allow accessing protected
 and private base class’ members or constructors. — *end note*]
 The *elements* of an aggregate are:
 - for an array, the array elements in increasing subscript order, or
 - for a class, the direct base classes in declaration order, followed by
-  the direct non-static data members ([[class.mem]]) that are not
- members of an anonymous union, in declaration order.
 When an aggregate is initialized by an initializer list as specified in
 [[dcl.init.list]], the elements of the initializer list are taken as
-initializers for the elements of the aggregate, in order. Each element
-is copy-initialized from the corresponding *initializer-clause*. If the
-*initializer-clause* is an expression and a narrowing conversion (
-[[dcl.init.list]]) is required to convert the expression, the program is
-ill-formed.
-[*Note 2*: If an *initializer-clause* is itself an initializer list,
-the element is list-initialized, which will result in a recursive
-application of the rules in this section if the element is an
   aggregate. — *end note*]
-[*Example 1*:
   ``` cpp
   struct A {
     int x;
     struct B {
       int i;
@@ -43,11 +76,10 @@ struct A {
     } b;
   } a = { 1, { 2, 3 } };
   ```
   initializes `a.x` with 1, `a.b.i` with 2, `a.b.j` with 3.
   ``` cpp
   struct base1 { int b1, b2 = 42; };
   struct base2 {
     base2() {
       b3 = 42;
@@ -60,46 +92,109 @@ struct derived : base1, base2 {
   derived d1{{1, 2}, {}, 4};
   derived d2{{}, {}, 4};
   ```
-initializes `d1.b1` with 1, `d1.b2` with 2, `d1.b3` with 42, `d1.d` with
-4, and `d2.b1` with 0, `d2.b2` with 42, `d2.b3` with 42, `d2.d` with 4.
 — *end example*]
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in  [[dcl.init]].
 An array of unknown bound initialized with a brace-enclosed
-*initializer-list* containing `n` *initializer-clause*s, where `n` shall
-be greater than zero, is defined as having `n` elements (
-[[dcl.array]]).
-[*Example 2*:
 ``` cpp
 int x[] = { 1, 3, 5 };
 ```
 declares and initializes `x` as a one-dimensional array that has three
 elements since no size was specified and there are three initializers.
 — *end example*]
-An empty initializer list `{}` shall not be used as the
-*initializer-clause* for an array of unknown bound.[^13]
-[*Note 3*:
 A default member initializer does not determine the bound for a member
 array of unknown bound. Since the default member initializer is ignored
-if a suitable *mem-initializer* is present ([[class.base.init]]), the
 default member initializer is not considered to initialize the array of
 unknown bound.
-[*Example 3*:
 ``` cpp
 struct S {
   int y[] = { 0 };          // error: non-static data member of incomplete type
 };
@@ -107,16 +202,16 @@ struct S {
 — *end example*]
 — *end note*]
-[*Note 4*:
-Static data members and unnamed bit-fields are not considered elements
-of the aggregate.
-[*Example 4*:
 ``` cpp
 struct A {
   int i;
   static int s;
@@ -133,86 +228,51 @@ unnamed bit-field before it.
 — *end example*]
 — *end note*]
 An *initializer-list* is ill-formed if the number of
-*initializer-clause*s exceeds the number of elements to initialize.
-[*Example 5*:
 ``` cpp
 char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
 ```
 is ill-formed.
 — *end example*]
-If there are fewer *initializer-clause*s in the list than there are
-elements in a non-union aggregate, then each element not explicitly
-initialized is initialized as follows:
-- If the element has a default member initializer ([[class.mem]]), the
-  element is initialized from that initializer.
-- Otherwise, if the element is not a reference, the element is
-  copy-initialized from an empty initializer list ([[dcl.init.list]]).
-- Otherwise, the program is ill-formed.
-If the aggregate is a union and the initializer list is empty, then
-- if any variant member has a default member initializer, that member is
-  initialized from its default member initializer;
-- otherwise, the first member of the union (if any) is copy-initialized
-  from an empty initializer list.
-[*Example 6*:
-``` cpp
-struct S { int a; const char* b; int c; int d = b[a]; };
-S ss = { 1, "asdf" };
-```
-initializes `ss.a` with 1, `ss.b` with `"asdf"`, `ss.c` with the value
-of an expression of the form `int{}` (that is, `0`), and `ss.d` with the
-value of `ss.b[ss.a]` (that is, `'s'`), and in
-``` cpp
-struct X { int i, j, k = 42; };
-X a[] = { 1, 2, 3, 4, 5, 6 };
-X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
-```
-`a` and `b` have the same value
-— *end example*]
-If a reference member is initialized from its default member initializer
-and a potentially-evaluated subexpression thereof is an aggregate
-initialization that would use that default member initializer, the
-program is ill-formed.
-[*Example 7*:
 ``` cpp
 struct A;
 extern A a;
 struct A {
   const A& a1 { A{a,a} };       // OK
   const A& a2 { A{} };          // error
 };
 A a{a,a};                       // OK
 ```
 — *end example*]
 If an aggregate class `C` contains a subaggregate element `e` with no
 elements, the *initializer-clause* for `e` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
 *initializer-clause*s for all elements of `C` following `e` are also
 omitted.
-[*Example 8*:
 ``` cpp
 struct S { } s;
 struct A {
   S s1;
@@ -231,13 +291,13 @@ struct A {
 — *end example*]
 When initializing a multi-dimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
-varying the fastest ([[dcl.array]]).
-[*Example 9*:
 ``` cpp
 int x[2][2] = { 3, 1, 4, 2 };
 ```
@@ -264,11 +324,11 @@ for a subaggregate does not begin with a left brace, then only enough
 *initializer-clause*s from the list are taken to initialize the elements
 of the subaggregate; any remaining *initializer-clause*s are left to
 initialize the next element of the aggregate of which the current
 subaggregate is an element.
-[*Example 10*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
@@ -296,22 +356,22 @@ The initializer for `y` begins with a left brace, but the one for `y[0]`
 does not, therefore three elements from the list are used. Likewise the
 next three are taken successively for `y[1]` and `y[2]`.
 — *end example*]
-All implicit type conversions (Clause  [[conv]]) are considered when
-initializing the element with an *assignment-expression*. If the
 *assignment-expression* can initialize an element, the element is
 initialized. Otherwise, if the element is itself a subaggregate, brace
 elision is assumed and the *assignment-expression* is considered for the
 initialization of the first element of the subaggregate.
-[*Note 5*: As specified above, brace elision cannot apply to
 subaggregates with no elements; an *initializer-clause* for the entire
 subobject is required. — *end note*]
-[*Example 11*:
 ``` cpp
 struct A {
   int i;
   operator int();
@@ -328,35 +388,36 @@ Braces are elided around the *initializer-clause* for `b.a1.i`. `b.a1.i`
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
 — *end example*]
-[*Note 6*: An aggregate array or an aggregate class may contain
-elements of a class type with a user-provided constructor (
-[[class.ctor]]). Initialization of these aggregate objects is described
 in  [[class.expl.init]]. — *end note*]
-[*Note 7*: Whether the initialization of aggregates with static storage
 duration is static or dynamic is specified in  [[basic.start.static]],
 [[basic.start.dynamic]], and  [[stmt.dcl]]. — *end note*]
-When a union is initialized with a brace-enclosed initializer, the
-braces shall only contain an *initializer-clause* for the first
-non-static data member of the union.
-[*Example 12*:
 ``` cpp
 union u { int a; const char* b; };
 u a = { 1 };
 u b = a;
 u c = 1;                        // error
 u d = { 0, "asdf" };            // error
 u e = { "asdf" };               // error
 ```
 — *end example*]
-[*Note 8*: As described above, the braces around the
 *initializer-clause* for a union member can be omitted if the union is a
 member of another aggregate. — *end note*]

 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
+An *aggregate* is an array or a class [[class]] with
+- no user-declared or inherited constructors [[class.ctor]],
+- no private or protected direct non-static data members
+  [[class.access]],
+- no virtual functions [[class.virtual]], and
+- no virtual, private, or protected base classes [[class.mi]].
 [*Note 1*: Aggregate initialization does not allow accessing protected
 and private base class’ members or constructors. — *end note*]
 The *elements* of an aggregate are:
 - for an array, the array elements in increasing subscript order, or
 - for a class, the direct base classes in declaration order, followed by
+  the direct non-static data members [[class.mem]] that are not members
+  of an anonymous union, in declaration order.
 When an aggregate is initialized by an initializer list as specified in
 [[dcl.init.list]], the elements of the initializer list are taken as
+initializers for the elements of the aggregate. The *explicitly
+initialized elements* of the aggregate are determined as follows:
+- If the initializer list is a *designated-initializer-list*, the
+  aggregate shall be of class type, the *identifier* in each
+  *designator* shall name a direct non-static data member of the class,
+  and the explicitly initialized elements of the aggregate are the
+  elements that are, or contain, those members.
+- If the initializer list is an *initializer-list*, the explicitly
+  initialized elements of the aggregate are the first n elements of the
+  aggregate, where n is the number of elements in the initializer list.
+- Otherwise, the initializer list must be `{}`, and there are no
+  explicitly initialized elements.
+For each explicitly initialized element:
+- If the element is an anonymous union object and the initializer list
+  is a *designated-initializer-list*, the anonymous union object is
+  initialized by the *designated-initializer-list* `{ `*D*` }`, where
+  *D* is the *designated-initializer-clause* naming a member of the
+  anonymous union object. There shall be only one such
+  *designated-initializer-clause*.
+  \[*Example 1*:
+  ``` cpp
+  struct C {
+    union {
+      int a;
+      const char* p;
+    };
+    int x;
+  } c = { .a = 1, .x = 3 };
+  ```
+  initializes `c.a` with 1 and `c.x` with 3.
+  — *end example*]
+- Otherwise, the element is copy-initialized from the corresponding
+  *initializer-clause* or is initialized with the
+  *brace-or-equal-initializer* of the corresponding
+  *designated-initializer-clause*. If that initializer is of the form
+  *assignment-expression* or `= `*assignment-expression* and a narrowing
+  conversion [[dcl.init.list]] is required to convert the expression,
+  the program is ill-formed.
+  \[*Note 2*: If an initializer is itself an initializer list, the
+  element is list-initialized, which will result in a recursive
+  application of the rules in this subclause if the element is an
   aggregate. — *end note*]
+  \[*Example 2*:
   ``` cpp
   struct A {
     int x;
     struct B {
       int i;
     } b;
   } a = { 1, { 2, 3 } };
   ```
   initializes `a.x` with 1, `a.b.i` with 2, `a.b.j` with 3.
   ``` cpp
   struct base1 { int b1, b2 = 42; };
   struct base2 {
     base2() {
       b3 = 42;
   derived d1{{1, 2}, {}, 4};
   derived d2{{}, {}, 4};
   ```
+ initializes `d1.b1` with 1, `d1.b2` with 2, `d1.b3` with 42, `d1.d`
+  with 4, and `d2.b1` with 0, `d2.b2` with 42, `d2.b3` with 42, `d2.d`
+  with 4.
+  — *end example*]
+For a non-union aggregate, each element that is not an explicitly
+initialized element is initialized as follows:
+- If the element has a default member initializer [[class.mem]], the
+  element is initialized from that initializer.
+- Otherwise, if the element is not a reference, the element is
+  copy-initialized from an empty initializer list [[dcl.init.list]].
+- Otherwise, the program is ill-formed.
+If the aggregate is a union and the initializer list is empty, then
+- if any variant member has a default member initializer, that member is
+  initialized from its default member initializer;
+- otherwise, the first member of the union (if any) is copy-initialized
+  from an empty initializer list.
+[*Example 3*:
+``` cpp
+struct S { int a; const char* b; int c; int d = b[a]; };
+S ss = { 1, "asdf" };
+```
+initializes `ss.a` with 1, `ss.b` with `"asdf"`, `ss.c` with the value
+of an expression of the form `int{}` (that is, `0`), and `ss.d` with the
+value of `ss.b[ss.a]` (that is, `'s'`), and in
+``` cpp
+struct X { int i, j, k = 42; };
+X a[] = { 1, 2, 3, 4, 5, 6 };
+X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
+```
+`a` and `b` have the same value
+``` cpp
+struct A {
+  string a;
+  int b = 42;
+  int c = -1;
+};
+```
+`A{.c=21}` has the following steps:
+- Initialize `a` with `{}`
+- Initialize `b` with `= 42`
+- Initialize `c` with `= 21`
 — *end example*]
+The initializations of the elements of the aggregate are evaluated in
+the element order. That is, all value computations and side effects
+associated with a given element are sequenced before those of any
+element that follows it in order.
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in  [[dcl.init]].
+The destructor for each element of class type is potentially invoked
+[[class.dtor]] from the context where the aggregate initialization
+occurs.
+[*Note 3*: This provision ensures that destructors can be called for
+fully-constructed subobjects in case an exception is thrown
+[[except.ctor]]. — *end note*]
 An array of unknown bound initialized with a brace-enclosed
+*initializer-list* containing `n` *initializer-clause*s is defined as
+having `n` elements [[dcl.array]].
+[*Example 4*:
 ``` cpp
 int x[] = { 1, 3, 5 };
 ```
 declares and initializes `x` as a one-dimensional array that has three
 elements since no size was specified and there are three initializers.
 — *end example*]
+An array of unknown bound shall not be initialized with an empty
+*braced-init-list* `{}`. [^6]
+[*Note 4*:
 A default member initializer does not determine the bound for a member
 array of unknown bound. Since the default member initializer is ignored
+if a suitable *mem-initializer* is present [[class.base.init]], the
 default member initializer is not considered to initialize the array of
 unknown bound.
+[*Example 5*:
 ``` cpp
 struct S {
   int y[] = { 0 };          // error: non-static data member of incomplete type
 };
 — *end example*]
 — *end note*]
+[*Note 5*:
+Static data members, non-static data members of anonymous union members,
+and unnamed bit-fields are not considered elements of the aggregate.
+[*Example 6*:
 ``` cpp
 struct A {
   int i;
   static int s;
 — *end example*]
 — *end note*]
 An *initializer-list* is ill-formed if the number of
+*initializer-clause*s exceeds the number of elements of the aggregate.
+[*Example 7*:
 ``` cpp
 char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
 ```
 is ill-formed.
 — *end example*]
+If a member has a default member initializer and a potentially-evaluated
+subexpression thereof is an aggregate initialization that would use that
+default member initializer, the program is ill-formed.
+[*Example 8*:
 ``` cpp
 struct A;
 extern A a;
 struct A {
   const A& a1 { A{a,a} };       // OK
   const A& a2 { A{} };          // error
 };
 A a{a,a};                       // OK
+struct B {
+  int n = B{}.n;                // error
+};
 ```
 — *end example*]
 If an aggregate class `C` contains a subaggregate element `e` with no
 elements, the *initializer-clause* for `e` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
 *initializer-clause*s for all elements of `C` following `e` are also
 omitted.
+[*Example 9*:
 ``` cpp
 struct S { } s;
 struct A {
   S s1;
 — *end example*]
 When initializing a multi-dimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
+varying the fastest [[dcl.array]].
+[*Example 10*:
 ``` cpp
 int x[2][2] = { 3, 1, 4, 2 };
 ```
 *initializer-clause*s from the list are taken to initialize the elements
 of the subaggregate; any remaining *initializer-clause*s are left to
 initialize the next element of the aggregate of which the current
 subaggregate is an element.
+[*Example 11*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
 does not, therefore three elements from the list are used. Likewise the
 next three are taken successively for `y[1]` and `y[2]`.
 — *end example*]
+All implicit type conversions [[conv]] are considered when initializing
+the element with an *assignment-expression*. If the
 *assignment-expression* can initialize an element, the element is
 initialized. Otherwise, if the element is itself a subaggregate, brace
 elision is assumed and the *assignment-expression* is considered for the
 initialization of the first element of the subaggregate.
+[*Note 6*: As specified above, brace elision cannot apply to
 subaggregates with no elements; an *initializer-clause* for the entire
 subobject is required. — *end note*]
+[*Example 12*:
 ``` cpp
 struct A {
   int i;
   operator int();
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
 — *end example*]
+[*Note 7*: An aggregate array or an aggregate class may contain
+elements of a class type with a user-declared constructor
+[[class.ctor]]. Initialization of these aggregate objects is described
 in  [[class.expl.init]]. — *end note*]
+[*Note 8*: Whether the initialization of aggregates with static storage
 duration is static or dynamic is specified in  [[basic.start.static]],
 [[basic.start.dynamic]], and  [[stmt.dcl]]. — *end note*]
+When a union is initialized with an initializer list, there shall not be
+more than one explicitly initialized element.
+[*Example 13*:
 ``` cpp
 union u { int a; const char* b; };
 u a = { 1 };
 u b = a;
 u c = 1;                        // error
 u d = { 0, "asdf" };            // error
 u e = { "asdf" };               // error
+u f = { .b = "asdf" };
+u g = { .a = 1, .b = "asdf" };  // error
 ```
 — *end example*]
+[*Note 9*: As described above, the braces around the
 *initializer-clause* for a union member can be omitted if the union is a
 member of another aggregate. — *end note*]

Diff to HTML by rtfpessoa