9 Declarations [dcl.dcl]

9.4 Initializers [dcl.init]

9.4.1 Aggregates [dcl.init.aggr]

An aggregate is an array or a class ([class]) with

(1.1)
no user-declared or inherited constructors ([class.ctor]),
(1.2)
no private or protected direct non-static data members ([class.access]),
(1.3)
no virtual functions ([class.virtual]), and
(1.4)
no virtual, private, or protected base classes ([class.mi]).

[ Note

Aggregate initialization does not allow accessing protected and private base class' members or constructors.

— end note

]

The elements of an aggregate are:

(2.1)
for an array, the array elements in increasing subscript order, or
(2.2)
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:

(3.1)
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.
(3.2)
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.
(3.3)
Otherwise, the initializer list must be {}, and there are no explicitly initialized elements.

For each explicitly initialized element:

(4.1)
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
:
```
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
]
(4.2)
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
: 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
:
```
struct A {
  int x;
  struct B {
    int i;
    int j;
  } b;
} a = { 1, { 2, 3 } };
```
initializes a.x with 1, a.b.i with 2, a.b.j with 3.
```
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
]

For a non-union aggregate, each element that is not an explicitly initialized element is initialized as follows:

(5.1)
If the element has a default member initializer ([class.mem]), the element is initialized from that initializer.
(5.2)
Otherwise, if the element is not a reference, the element is copy-initialized from an empty initializer list ([dcl.init.list]).
(5.3)
Otherwise, the program is ill-formed.

If the aggregate is a union and the initializer list is empty, then

(5.4)
if any variant member has a default member initializer, that member is initialized from its default member initializer;
(5.5)
otherwise, the first member of the union (if any) is copy-initialized from an empty initializer list.

[ Example

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

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

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

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-clauses is defined as having n elements ([dcl.array]).

[ Example

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 {}.91

[ Note

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

struct S {
  int y[] = { 0 };          // error: non-static data member of incomplete type
};

— end example

]

— end note

]

[ Note

Static data members, non-static data members of anonymous union members, and unnamed bit-fields are not considered elements of the aggregate.

[ Example

struct A {
  int i;
  static int s;
  int j;
  int :17;
  int k;
} 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-clauses exceeds the number of elements of the aggregate.

[ Example

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

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-clauses for all elements of C following e are also omitted.

[ Example

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 multi-dimensional array, the initializer-clauses initialize the elements with the last (rightmost) index of the array varying the fastest ([dcl.array]).

[ Example

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 x[1][1] to 2.

On the other hand,

float y[4][3] = {
  { 1 }, { 2 }, { 3 }, { 4 }
};

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-clauses initializes the elements of a subaggregate; it is erroneous for there to be more initializer-clauses than elements.

If, however, the initializer-list for a subaggregate does not begin with a left brace, then only enough initializer-clauses from the list are taken to initialize the elements of the subaggregate; any remaining initializer-clauses are left to initialize the next element of the aggregate of which the current subaggregate is an element.

[ Example

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,

float y[4][3] = {
  1, 3, 5, 2, 4, 6, 3, 5, 7
};

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

As specified above, brace elision cannot apply to subaggregates with no elements; an initializer-clause for the entire subobject is required.

— end note

]

[ Example

struct A {
  int i;
  operator int();
};
struct B {
  A a1, a2;
  int z;
};
A a;
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.

— end example

]

[ Note

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

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

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

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

]

91)

The syntax provides for empty braced-init-lists, but nonetheless C++ does not have zero length arrays.

⮥