9 Declarations [dcl.dcl]

9.4 Initializers [dcl.init]

9.4.1 General [dcl.init.general]

The process of initialization described in [dcl.init] applies to all initializations regardless of syntactic context, including the initialization of a function parameter ([expr.call]), the initialization of a return value ([stmt.return]), or when an initializer follows a declarator.

initializer:
brace-or-equal-initializer
( expression-list )

brace-or-equal-initializer:
= initializer-clause
braced-init-list

initializer-clause:
assignment-expression
braced-init-list

braced-init-list:
{ initializer-list ,

_{o p t}

}
{ designated-initializer-list ,

_{o p t}

}
{ }

initializer-list:
initializer-clause ...

_{o p t}

initializer-list , initializer-clause ...

_{o p t}

designated-initializer-list:
designated-initializer-clause
designated-initializer-list , designated-initializer-clause

designated-initializer-clause:
designator brace-or-equal-initializer

designator:
. identifier

expr-or-braced-init-list:
expression
braced-init-list

[Note 1:

The rules in [dcl.init] apply even if the grammar permits only the brace-or-equal-initializer form of initializer in a given context.

— end note]

Except for objects declared with the constexpr specifier, for which see [dcl.constexpr], an initializer in the definition of a variable can consist of arbitrary expressions involving literals and previously declared variables and functions, regardless of the variable's storage duration.

[Example 1: int f(int); int a = 2; int b = f(a); int c(b); — end example]

[Note 2:

Default arguments are more restricted; see [dcl.fct.default].

— end note]

[Note 3:

The order of initialization of variables with static storage duration is described in [basic.start] and [stmt.dcl].

— end note]

A declaration of a block-scope variable with external or internal linkage that has an initializer is ill-formed.

To zero-initialize an object or reference of type T means:

(6.1)
if T is a scalar type, the object is initialized to the value obtained by converting the integer literal 0 (zero) to T;94
(6.2)
if T is a (possibly cv-qualified) non-union class type, its padding bits are initialized to zero bits and each non-static data member, each non-virtual base class subobject, and, if the object is not a base class subobject, each virtual base class subobject is zero-initialized;
(6.3)
if T is a (possibly cv-qualified) union type, its padding bits are initialized to zero bits and the object's first non-static named data member is zero-initialized;
(6.4)
if T is an array type, each element is zero-initialized;
(6.5)
if T is a reference type, no initialization is performed.

To default-initialize an object of type T means:

(7.1)
If T is a (possibly cv-qualified) class type ([class]), constructors are considered.

The applicable constructors are enumerated ([over.match.ctor]), and the best one for the initializer () is chosen through overload resolution ([over.match]).

The constructor thus selected is called, with an empty argument list, to initialize the object.
(7.2)
If T is an array type, each element is default-initialized.
(7.3)
Otherwise, no initialization is performed.

A class type T is const-default-constructible if default-initialization of T would invoke a user-provided constructor of T (not inherited from a base class) or if

(7.4)
each direct non-variant non-static data member M of T has a default member initializer or, if M is of class type X (or array thereof), X is const-default-constructible,
(7.5)
if T is a union with at least one non-static data member, exactly one variant member has a default member initializer,
(7.6)
if T is not a union, for each anonymous union member with at least one non-static data member (if any), exactly one non-static data member has a default member initializer, and
(7.7)
each potentially constructed base class of T is const-default-constructible.

If a program calls for the default-initialization of an object of a const-qualified type T, T shall be a const-default-constructible class type or array thereof.

To value-initialize an object of type T means:

(8.1)
if T is a (possibly cv-qualified) class type ([class]), then
- (8.1.1)
  if T has either no default constructor ([class.default.ctor]) or a default constructor that is user-provided or deleted, then the object is default-initialized;
- (8.1.2)
  otherwise, the object is zero-initialized and the semantic constraints for default-initialization are checked, and if T has a non-trivial default constructor, the object is default-initialized;
(8.2)
if T is an array type, then each element is value-initialized;
(8.3)
otherwise, the object is zero-initialized.

A program that calls for default-initialization or value-initialization of an entity of reference type is ill-formed.

[Note 4:

For every object of static storage duration, static initialization ([basic.start.static]) is performed at program startup before any other initialization takes place.

In some cases, additional initialization is done later.

— end note]

If no initializer is specified for an object, the object is default-initialized.

An initializer for a static member is in the scope of the member's class.

[Example 2: int a; struct X { static int a; static int b; }; int X::a = 1; int X::b = a; // X::b = X::a — end example]

If the entity being initialized does not have class type, the expression-list in a parenthesized initializer shall be a single expression.

The initialization that occurs in the = form of a brace-or-equal-initializer or condition ([stmt.select]), as well as in argument passing, function return, throwing an exception ([except.throw]), handling an exception ([except.handle]), and aggregate member initialization ([dcl.init.aggr]), is called copy-initialization.

[Note 5:

Copy-initialization can invoke a move ([class.copy.ctor]).

— end note]

The initialization that occurs

(15.1)
for an initializer that is a parenthesized expression-list or a braced-init-list,
(15.2)
for a new-initializer ([expr.new]),
(15.3)
in a static_cast expression ([expr.static.cast]),
(15.4)
in a functional notation type conversion, and
(15.5)
in the braced-init-list form of a condition

is called direct-initialization.

The semantics of initializers are as follows.

The destination type is the type of the object or reference being initialized and the source type is the type of the initializer expression.

If the initializer is not a single (possibly parenthesized) expression, the source type is not defined.

(16.1)
If the initializer is a (non-parenthesized) braced-init-list or is = braced-init-list, the object or reference is list-initialized ([dcl.init.list]).
(16.2)
If the destination type is a reference type, see [dcl.init.ref].
(16.3)
If the destination type is an array of characters, an array of char8_t, an array of char16_t, an array of char32_t, or an array of wchar_t, and the initializer is a string-literal, see [dcl.init.string].
(16.4)
If the initializer is (), the object is value-initialized.

[Note 6:
Since () is not permitted by the syntax for initializer, X a(); is not the declaration of an object of class X, but the declaration of a function taking no argument and returning an X.

The form () is permitted in certain other initialization contexts ([expr.new], [expr.type.conv], [class.base.init]).
— end note]
(16.5)
Otherwise, if the destination type is an array, the object is initialized as follows.

Let $x_{1}$ , …, $x_{k}$ be the elements of the expression-list.

If the destination type is an array of unknown bound, it is defined as having k elements.

Let n denote the array size after this potential adjustment.

If k is greater than n, the program is ill-formed.

Otherwise, the $i^{th}$ array element is copy-initialized with $x_{i}$ for each $1 \leq i \leq k$ , and value-initialized for each $k < i \leq n$ .

For each $1 \leq i < j \leq n$ , every value computation and side effect associated with the initialization of the $i^{th}$ element of the array is sequenced before those associated with the initialization of the $j^{th}$ element.
(16.6)
Otherwise, if the destination type is a (possibly cv-qualified) class type:
- (16.6.1)
  If the initializer expression is a prvalue and the cv-unqualified version of the source type is the same class as the class of the destination, the initializer expression is used to initialize the destination object.
  
  [Example 3:
  T x = T(T(T())); calls the T default constructor to initialize x.
  — end example]
- (16.6.2)
  Otherwise, if the initialization is direct-initialization, or if it is copy-initialization where the cv-unqualified version of the source type is the same class as, or a derived class of, the class of the destination, constructors are considered.
  
  The applicable constructors are enumerated ([over.match.ctor]), and the best one is chosen through overload resolution ([over.match]).
  
  Then:
  (16.6.2.1)
  If overload resolution is successful, the selected constructor is called to initialize the object, with the initializer expression or expression-list as its argument(s).
  (16.6.2.2)
  Otherwise, if no constructor is viable, the destination type is an aggregate class, and the initializer is a parenthesized expression-list, the object is initialized as follows.
  
  Let $e_{1}$ , …, $e_{n}$ be the elements of the aggregate ([dcl.init.aggr]).
  
  Let $x_{1}$ , …, $x_{k}$ be the elements of the expression-list.
  
  If k is greater than n, the program is ill-formed.
  
  The element $e_{i}$ is copy-initialized with $x_{i}$ for $1 \leq i \leq k$ .
  
  The remaining elements are initialized with their default member initializers, if any, and otherwise are value-initialized.
  
  For each $1 \leq i < j \leq n$ , every value computation and side effect associated with the initialization of $e_{i}$ is sequenced before those associated with the initialization of $e_{j}$ .
  
  [Note 7:
  By contrast with direct-list-initialization, narrowing conversions ([dcl.init.list]) are permitted, designators are not permitted, a temporary object bound to a reference does not have its lifetime extended ([class.temporary]), and there is no brace elision.
  
  [Example 4: struct A { int a; int&& r; }; int f(); int n = 10; A a1{1, f()}; // OK, lifetime is extended A a2(1, f()); // well-formed, but dangling reference A a3{1.0, 1}; // error: narrowing conversion A a4(1.0, 1); // well-formed, but dangling reference A a5(1.0, std::move(n)); // OK — end example]
  — end note]
  (16.6.2.3)
  Otherwise, the initialization is ill-formed.
- (16.6.3)
  Otherwise (i.e., for the remaining copy-initialization cases), user-defined conversions that can convert from the source type to the destination type or (when a conversion function is used) to a derived class thereof are enumerated as described in [over.match.copy], and the best one is chosen through overload resolution ([over.match]).
  
  If the conversion cannot be done or is ambiguous, the initialization is ill-formed.
  
  The function selected is called with the initializer expression as its argument; if the function is a constructor, the call is a prvalue of the cv-unqualified version of the destination type whose result object is initialized by the constructor.
  
  The call is used to direct-initialize, according to the rules above, the object that is the destination of the copy-initialization.
(16.7)
Otherwise, if the source type is a (possibly cv-qualified) class type, conversion functions are considered.

The applicable conversion functions are enumerated ([over.match.conv]), and the best one is chosen through overload resolution ([over.match]).

The user-defined conversion so selected is called to convert the initializer expression into the object being initialized.

If the conversion cannot be done or is ambiguous, the initialization is ill-formed.
(16.8)
Otherwise, if the initialization is direct-initialization, the source type is std::nullptr_t, and the destination type is bool, the initial value of the object being initialized is false.
(16.9)
Otherwise, the initial value of the object being initialized is the (possibly converted) value of the initializer expression.

A standard conversion sequence ([conv]) will be used, if necessary, to convert the initializer expression to the cv-unqualified version of the destination type; no user-defined conversions are considered.

If the conversion cannot be done, the initialization is ill-formed.

When initializing a bit-field with a value that it cannot represent, the resulting value of the bit-field is implementation-defined.

[Note 8:
An expression of type “cv1 T” can initialize an object of type “cv2 T” independently of the cv-qualifiers cv1 and cv2.
int a; const int b = a; int c = b; — end note]

An initializer-clause followed by an ellipsis is a pack expansion ([temp.variadic]).

If the initializer is a parenthesized expression-list, the expressions are evaluated in the order specified for function calls ([expr.call]).

The same identifier shall not appear in multiple designators of a designated-initializer-list.

An object whose initialization has completed is deemed to be constructed, even if the object is of non-class type or no constructor of the object's class is invoked for the initialization.

[Note 9:

Such an object might have been value-initialized or initialized by aggregate initialization ([dcl.init.aggr]) or by an inherited constructor ([class.inhctor.init]).

— end note]

Destroying an object of class type invokes the destructor of the class.

Destroying a scalar type has no effect other than ending the lifetime of the object ([basic.life]).

Destroying an array destroys each element in reverse subscript order.

A declaration that specifies the initialization of a variable, whether from an explicit initializer or by default-initialization, is called the initializing declaration of that variable.

[Note 10:

In most cases this is the defining declaration ([basic.def]) of the variable, but the initializing declaration of a non-inline static data member ([class.static.data]) might be the declaration within the class definition and not the definition at namespace scope.

— end note]

94)

As specified in [conv.ptr], converting an integer literal whose value is 0 to a pointer type results in a null pointer value.

⮥