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

Files changed (1) hide show

tmp/tmp8e1e4vce/{from.md → to.md} +181 -55

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

@@ -1,23 +1,40 @@
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
-An *aggregate* is an array or a class (Clause  [[class]]) with no
-user-provided constructors ([[class.ctor]]), no private or protected
-non-static data members (Clause  [[class.access]]), no base classes
-(Clause  [[class.derived]]), and no virtual functions (
-[[class.virtual]]).
-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 members of the aggregate, in increasing subscript
-or member order. Each member 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. If an *initializer-clause* is
-itself an initializer list, the member is list-initialized, which will
-result in a recursive application of the rules in this section if the
-member is an aggregate.
 ``` cpp
 struct A {
   int x;
   struct B {
@@ -27,29 +44,79 @@ struct A {
 } a = { 1, { 2, 3 } };
 ```
 initializes `a.x` with 1, `a.b.i` with 2, `a.b.j` with 3.
 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 size 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]]).
 ``` 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.
 An empty initializer list `{}` shall not be used as the
-*initializer-clause * for an array of unknown bound.[^15]
-Static data members and anonymous bit-fields are not considered members
-of the class for purposes of aggregate initialization.
 ``` cpp
 struct A {
   int i;
   static int s;
@@ -59,27 +126,47 @@ struct A {
 } a = { 1, 2, 3 };
 ```
 Here, the second initializer 2 initializes `a.j` and not the static data
 member `A::s`, and the third initializer 3 initializes `a.k` and not the
-anonymous bit-field before it.
 An *initializer-list* is ill-formed if the number of
-*initializer-clause*s exceeds the number of members or elements to
-initialize.
 ``` cpp
 char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
 ```
 is ill-formed.
 If there are fewer *initializer-clause*s in the list than there are
-members in the aggregate, then each member not explicitly initialized
-shall be initialized from its *brace-or-equal-initializer* or, if there
-is no *brace-or-equal-initializer*, from an empty initializer list (
-[[dcl.init.list]]).
 ``` cpp
 struct S { int a; const char* b; int c; int d = b[a]; };
 S ss = { 1, "asdf" };
 ```
@@ -94,17 +181,39 @@ X a[] = { 1, 2, 3, 4, 5, 6 };
 X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
 ```
 `a` and `b` have the same value
-If an aggregate class `C` contains a subaggregate member `m` that has no
-members for purposes of aggregate initialization, the
-*initializer-clause* for `m` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
-*initializer-clause*s for all members of `C` following `m` are also
 omitted.
 ``` cpp
 struct S { } s;
 struct A {
   S s1;
   int i1;
@@ -118,17 +227,18 @@ struct A {
   s,                // Required initialization
   0
 };                  // Initialization not required for A::s3 because A::i3 is also not initialized
 ```
-If an incomplete or empty *initializer-list* leaves a member of
-reference type uninitialized, the program is ill-formed.
 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]]).
 ``` cpp
 int x[2][2] = { 3, 1, 4, 2 };
 ```
 initializes `x[0][0]` to `3`, `x[0][1]` to `1`, `x[1][0]` to `4`, and
@@ -141,20 +251,24 @@ float y[4][3] = {
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
 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 members of
-a subaggregate; it is erroneous for there to be more
-*initializer-clause*s than members. 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 members
 of the subaggregate; any remaining *initializer-clause*s are left to
-initialize the next member of the aggregate of which the current
-subaggregate is a member.
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
@@ -180,19 +294,24 @@ float y[4][3] = {
 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]`.
 All implicit type conversions (Clause  [[conv]]) are considered when
-initializing the aggregate member with an *assignment-expression*. If
-the *assignment-expression* can initialize a member, the member is
-initialized. Otherwise, if the member is itself a subaggregate, brace
 elision is assumed and the *assignment-expression* is considered for the
-initialization of the first member of the subaggregate. As specified
-above, brace elision cannot apply to subaggregates with no members for
-purposes of aggregate initialization; an *initializer-clause* for the
-entire subobject is required.
 ``` cpp
 struct A {
   int i;
   operator int();
@@ -207,30 +326,37 @@ B b = { 4, a, a };
 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.
-An aggregate array or an aggregate class may contain members of a class
-type with a user-provided constructor ([[class.ctor]]). Initialization
-of these aggregate objects is described in  [[class.expl.init]].
-Whether the initialization of aggregates with static storage duration is
-static or dynamic is specified in  [[basic.start.init]] and
-[[stmt.dcl]].
 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.
 ``` 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
 ```
-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.

 ### 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 {
 } 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;
+  }
+  int b3;
+};
+struct derived : base1, base2 {
+  int d;
+};
+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
+};
+```
+— *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;
 } a = { 1, 2, 3 };
 ```
 Here, the second initializer 2 initializes `a.j` and not the static data
 member `A::s`, and the third initializer 3 initializes `a.k` and not the
+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" };
 ```
 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;
   int i1;
   s,                // Required initialization
   0
 };                  // Initialization not required for A::s3 because A::i3 is also not initialized
 ```
+— *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 };
 ```
 initializes `x[0][0]` to `3`, `x[0][1]` to `1`, `x[1][0]` to `4`, and
 ```
 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 10*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
 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();
 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*]

Diff to HTML by rtfpessoa