[dcl.init.aggr] - C++23 → Trunk

Files changed (1) hide show

tmp/tmptt50yoc5/{from.md → to.md} +146 -103

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

@@ -8,11 +8,11 @@ An *aggregate* is an array or a class [[class]] with
 - no private or protected direct base classes [[class.access.base]], and
 - no virtual functions [[class.virtual]] or virtual 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
@@ -28,13 +28,13 @@ initialized elements* of the aggregate are determined as follows:
   *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 a brace-enclosed *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:
@@ -54,21 +54,26 @@ For each explicitly initialized element:
   } 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 the initialization is by
-  *designated-initializer-clause*, its form determines whether
-  copy-initialization or direct-initialization is
   performed. — *end note*]
   \[*Note 3*: 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*:
@@ -127,19 +132,11 @@ 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;
@@ -161,21 +158,21 @@ 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 4*: 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 };
@@ -184,10 +181,24 @@ 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 5*:
@@ -195,11 +206,11 @@ 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
 };
@@ -212,11 +223,11 @@ struct S {
 [*Note 6*:
 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;
@@ -232,23 +243,10 @@ 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 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*:
@@ -267,42 +265,15 @@ struct B {
 };
 ```
 — *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;
-  int i1;
-  S s2;
-  int i2;
-  S s3;
-  int i3;
-} a = {
-  { },              // Required initialization
-  0,
-  s,                // Required initialization
-  0
-};                  // Initialization not required for A::s3 because A::i3 is also not initialized
-```
-— *end example*]
 When initializing a multidimensional 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 };
 ```
@@ -318,23 +289,77 @@ float y[4][3] = {
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
 — *end example*]
-Braces can be elided in an *initializer-list* as follows. If the
-*initializer-list* begins with a left brace, then the succeeding
-comma-separated list of *initializer-clause*s initializes the elements
-of a subaggregate; it is erroneous for there to be more
-*initializer-clause*s than elements. If, however, the *initializer-list*
-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 11*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
   { 3, 5, 7 },
@@ -342,15 +367,15 @@ float y[4][3] = {
 ```
 is a completely-braced initialization: 1, 3, and 5 initialize the first
 row of the array `y[0]`, namely `y[0][0]`, `y[0][1]`, and `y[0][2]`.
 Likewise the next two lines initialize `y[1]` and `y[2]`. The
-initializer ends early and therefore `y[3]`s elements are initialized as
-if explicitly initialized with an expression of the form `float()`, that
-is, are initialized with `0.0`. In the following example, braces in the
-*initializer-list* are elided; however the *initializer-list* has the
-same effect as the completely-braced *initializer-list* of the above
 example,
 ``` cpp
 float y[4][3] = {
   1, 3, 5, 2, 4, 6, 3, 5, 7
@@ -361,22 +386,39 @@ 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 [[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 7*: 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();
@@ -393,23 +435,24 @@ 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 8*: An aggregate array or an aggregate class can 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 9*: 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;
@@ -420,9 +463,9 @@ u f = { .b = "asdf" };
 u g = { .a = 1, .b = "asdf" };  // error
 ```
 — *end example*]
-[*Note 10*: 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*]

 - no private or protected direct base classes [[class.access.base]], and
 - no virtual functions [[class.virtual]] or virtual base classes
   [[class.mi]].
 [*Note 1*: Aggregate initialization does not allow accessing protected
+and private base class’ members, including 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
   *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 a brace-enclosed *initializer-list*, the
+  explicitly initialized elements of the aggregate are those for which
+ an element of the initializer list appertains to the aggregate element
+ or to a subobject thereof (see below).
 - Otherwise, the initializer list must be `{}`, and there are no
   explicitly initialized elements.
 For each explicitly initialized element:
   } c = { .a = 1, .x = 3 };
   ```
   initializes `c.a` with 1 and `c.x` with 3.
   — *end example*]
+- Otherwise, if the initializer list is a brace-enclosed
+  *designated-initializer-list*, the element is initialized with the
   *brace-or-equal-initializer* of the corresponding
   *designated-initializer-clause*. If that initializer is of the form
+  `= `*assignment-expression* and a narrowing conversion
+  [[dcl.init.list]] is required to convert the expression, the program
+  is ill-formed. \[*Note 2*: The form of the initializer determines
+ whether copy-initialization or direct-initialization is
   performed. — *end note*]
+- Otherwise, the initializer list is a brace-enclosed
+  *initializer-list*. If an *initializer-clause* appertains to the
+  aggregate element, then the aggregate element is copy-initialized from
+  the *initializer-clause*. Otherwise, the aggregate element is
+  copy-initialized from a brace-enclosed *initializer-list* consisting
+  of all of the *initializer-clause*s that appertain to subobjects of
+  the aggregate element, in the order of appearance.
   \[*Note 3*: 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*:
 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'`).
 ``` cpp
 struct A {
   string a;
   int b = 42;
 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 other than an anonymous
+union member is potentially invoked [[class.dtor]] from the context
+where the aggregate initialization occurs.
 [*Note 4*: This provision ensures that destructors can be called for
 fully-constructed subobjects in case an exception is thrown
 [[except.ctor]]. — *end note*]
+The number of elements [[dcl.array]] in an array of unknown bound
+initialized with a brace-enclosed *initializer-list* is the number of
+explicitly initialized elements of the 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*]
+[*Example 5*:
+In
+``` cpp
+struct X { int i, j, k; };
+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*]
 An array of unknown bound shall not be initialized with an empty
 *braced-init-list* `{}`.[^6]
 [*Note 5*:
 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 6*:
 ``` cpp
 struct S {
   int y[] = { 0 };          // error: non-static data member of incomplete type
 };
 [*Note 6*:
 Static data members, non-static data members of anonymous union members,
 and unnamed bit-fields are not considered elements of the aggregate.
+[*Example 7*:
 ``` cpp
 struct A {
   int i;
   static int s;
 — *end example*]
 — *end note*]
 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*:
 };
 ```
 — *end example*]
 When initializing a multidimensional 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 };
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
 — *end example*]
+Each *initializer-clause* in a brace-enclosed *initializer-list* is said
+to *appertain* to an element of the aggregate being initialized or to an
+element of one of its subaggregates. Considering the sequence of
+*initializer-clause*s, and the sequence of aggregate elements initially
+formed as the sequence of elements of the aggregate being initialized
+and potentially modified as described below, each *initializer-clause*
+appertains to the corresponding aggregate element if
+- the aggregate element is not an aggregate, or
+- the *initializer-clause* begins with a left brace, or
+- the *initializer-clause* is an expression and an implicit conversion
+  sequence can be formed that converts the expression to the type of the
+  aggregate element, or
+- the aggregate element is an aggregate that itself has no aggregate
+  elements.
+Otherwise, the aggregate element is an aggregate and that subaggregate
+is replaced in the list of aggregate elements by the sequence of its own
+aggregate elements, and the appertainment analysis resumes with the
+first such element and the same *initializer-clause*.
+[*Note 7*:
+These rules apply recursively to the aggregate’s subaggregates.
+[*Example 10*:
+In
+``` cpp
+struct S1 { int a, b; };
+struct S2 { S1 s, t; };
+S2 x[2] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+S2 y[2] = {
+  {
+    { 1, 2 },
+    { 3, 4 }
+  },
+  {
+    { 5, 6 },
+    { 7, 8 }
+  }
+};
+```
+`x` and `y` have the same value.
+— *end example*]
+— *end note*]
+This process continues until all *initializer-clause*s have been
+exhausted. If any *initializer-clause* remains that does not appertain
+to an element of the aggregate or one of its subaggregates, the program
+is ill-formed.
 [*Example 11*:
+``` cpp
+char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error: too many initializers
+```
+— *end example*]
+[*Example 12*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
   { 3, 5, 7 },
 ```
 is a completely-braced initialization: 1, 3, and 5 initialize the first
 row of the array `y[0]`, namely `y[0][0]`, `y[0][1]`, and `y[0][2]`.
 Likewise the next two lines initialize `y[1]` and `y[2]`. The
+initializer ends early and therefore `y[3]`’s elements are initialized
+as if explicitly initialized with an expression of the form `float()`,
+that is, are initialized with `0.0`. In the following example, braces in
+the *initializer-list* are elided; however the *initializer-list* has
+the same effect as the completely-braced *initializer-list* of the above
 example,
 ``` cpp
 float y[4][3] = {
   1, 3, 5, 2, 4, 6, 3, 5, 7
 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*]
+[*Note 8*:
+The initializer for an empty subaggregate is needed if any initializers
+are provided for subsequent elements.
+[*Example 13*:
+``` cpp
+struct S { } s;
+struct A {
+  S s1;
+  int i1;
+  S s2;
+  int i2;
+  S s3;
+  int i3;
+} a = {
+  { },              // Required initialization
+  0,
+  s,                // Required initialization
+  0
+};                  // Initialization not required for A::s3 because A::i3 is also not initialized
+```
+— *end example*]
+— *end note*]
+[*Example 14*:
 ``` 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 9*: An aggregate array or an aggregate class can 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 10*: 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 15*:
 ``` cpp
 union u { int a; const char* b; };
 u a = { 1 };
 u b = a;
 u g = { .a = 1, .b = "asdf" };  // error
 ```
 — *end example*]
+[*Note 11*: 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