[dcl.init] - C++20 → C++23

Files changed (1) hide show

tmp/tmpm618q014/{from.md → to.md} +152 -146

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

@@ -1,8 +1,10 @@
 ## Initializers <a id="dcl.init">[[dcl.init]]</a>
-The process of initialization described in this subclause 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.
@@ -57,13 +59,13 @@ designator:
 expr-or-braced-init-list:
     expression
     braced-init-list
 ```
-[*Note 1*: The rules in this subclause 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
@@ -85,26 +87,26 @@ int c(b);
 [*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:
-- if `T` is a scalar type [[basic.types]], the object is initialized to
-  the value obtained by converting the integer literal `0` (zero) to
-  `T`;[^5]
 - if `T` is a (possibly cv-qualified) non-union class type, its padding
-  bits [[basic.types]] 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;
 - if `T` is a (possibly cv-qualified) union type, its padding bits
-  [[basic.types]] are initialized to zero bits and the object’s first
-  non-static named data member is zero-initialized;
 - if `T` is an array type, each element is zero-initialized;
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
@@ -154,62 +156,25 @@ 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*]
-An object whose initializer is an empty set of parentheses, i.e., `()`,
-shall be value-initialized.
-[*Note 5*:
-Since `()` is not permitted by the syntax for *initializer*,
-``` cpp
-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*]
 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*:
-``` cpp
-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 6*: Copy-initialization may invoke a move
 [[class.copy.ctor]]. — *end note*]
 The initialization that occurs
 - for an *initializer* that is a parenthesized *expression-list* or a
@@ -234,10 +199,21 @@ defined.
 - 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]].
 - If the initializer is `()`, the object is value-initialized.
 - Otherwise, if the destination type is an array, the object is
   initialized as follows. Let x₁, …, xₖ 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
@@ -250,12 +226,12 @@ defined.
 - Otherwise, if the destination type is a (possibly cv-qualified) class
   type:
   - 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*]
   - 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
@@ -278,11 +254,11 @@ defined.
       \[*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*:
       ``` cpp
       struct A {
         int a;
         int&& r;
       };
@@ -340,13 +316,24 @@ defined.
   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 *designator*s of a
 *designated-initializer-list*.
@@ -368,23 +355,24 @@ 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*]
 ### 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:
@@ -397,29 +385,29 @@ The *elements* of an aggregate are:
 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;
@@ -436,11 +424,15 @@ For each explicitly initialized element:
   *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
@@ -536,11 +528,11 @@ 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
@@ -558,11 +550,11 @@ 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
@@ -578,11 +570,11 @@ struct S {
 — *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*:
@@ -665,11 +657,11 @@ struct A {
 };                  // 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 10*:
@@ -739,11 +731,11 @@ 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*:
@@ -764,16 +756,16 @@ 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 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.
@@ -791,23 +783,27 @@ 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*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 An array of ordinary character type [[basic.fundamental]], `char8_t`
-array, `char16_t` array, `char32_t` array, or `wchar_t` array can be
 initialized by an ordinary string literal, UTF-8 string literal, UTF-16
 string literal, UTF-32 string literal, or wide string literal,
 respectively, or by an appropriately-typed *string-literal* enclosed in
-braces [[lex.string]]. Successive characters of the value of the
-*string-literal* initialize the elements of the array.
 [*Example 1*:
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
@@ -835,12 +831,12 @@ If there are fewer initializers than there are array elements, each
 element not explicitly initialized shall be zero-initialized
 [[dcl.init]].
 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
-A variable whose declared type is “reference to type `T`” [[dcl.ref]]
-shall be initialized.
 [*Example 1*:
 ``` cpp
 int g(int) noexcept;
@@ -905,14 +901,14 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
     `T3`”[^7] (this conversion is selected by enumerating the applicable
     conversion functions [[over.match.ref]] and choosing the best one
     through overload resolution [[over.match]]),
-  then the reference is bound to the initializer expression lvalue in
- the first case and to the lvalue result of the conversion in the
- second case (or, in either case, to the appropriate base class
- subobject of the object).
   \[*Note 2*: The usual lvalue-to-rvalue [[conv.lval]], array-to-pointer
   [[conv.array]], and function-to-pointer [[conv.func]] standard
   conversions are not needed, and therefore are suppressed, when such
   direct bindings to lvalues are done. — *end note*]
   \[*Example 3*:
@@ -946,55 +942,57 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   - has a class type (i.e., `T2` is a class type), where `T1` is not
     reference-related to `T2`, and can be converted to an rvalue or
     function lvalue of type “*cv3* `T3`”, where “*cv1* `T1`” is
     reference-compatible with “*cv3* `T3`” (see  [[over.match.ref]]),
-  then the value of the initializer expression in the first case and the
- result of the conversion in the second case is called the converted
- initializer. If the converted initializer is a prvalue, its type `T4`
- is adjusted to type “*cv1* `T4`” [[conv.qual]] and the temporary
- materialization conversion [[conv.rval]] is applied. In any case, the
- reference is bound to the resulting glvalue (or to an appropriate base
-  class subobject).
   \[*Example 5*:
   ``` cpp
   struct A { };
   struct B : A { } b;
   extern B f();
-  const A& rca2 = f();                // bound to the A subobject of the B rvalue.
   A&& rra = f();                      // same as above
   struct X {
     operator B();
     operator int&();
   } x;
-  const A& r = x;                     // bound to the A subobject of the result of the conversion
   int i2 = 42;
-  int&& rri = static_cast<int&&>(i2); // bound directly to i2
-  B&& rrb = x;                        // bound directly to the result of operator B
   ```
   — *end example*]
 - Otherwise:
   - If `T1` or `T2` is a class type and `T1` is not reference-related to
     `T2`, user-defined conversions are considered using the rules for
     copy-initialization of an object of type “*cv1* `T1`” by
-    user-defined conversion ([[dcl.init]], [[over.match.copy]],
-    [[over.match.conv]]); the program is ill-formed if the corresponding
- non-reference copy-initialization would be ill-formed. The result of
- the call to the conversion function, as described for the
-    non-reference copy-initialization, is then used to direct-initialize
-    the reference. For this direct-initialization, user-defined
-    conversions are not considered.
   - Otherwise, the initializer expression is implicitly converted to a
-    prvalue of type “*cv1* `T1`”. The temporary materialization
- conversion is applied and the reference is bound to the result.
   If `T1` is reference-related to `T2`:
   - *cv1* shall be the same cv-qualification as, or greater
     cv-qualification than, *cv2*; and
   - if the reference is an rvalue reference, the initializer expression
-    shall not be an lvalue.
   \[*Example 6*:
   ``` cpp
   struct Banana { };
   struct Enigma { operator const Banana(); };
@@ -1025,11 +1023,11 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
 In all cases except the last (i.e., implicitly converting the
 initializer expression to the referenced type), the reference is said to
 *bind directly* to the initializer expression.
-[*Note 3*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
@@ -1051,12 +1049,12 @@ List-initialization can be used
 - as the initializer in a *new-expression* [[expr.new]]
 - in a `return` statement [[stmt.return]]
 - as a *for-range-initializer* [[stmt.iter]]
 - as a function argument [[expr.call]]
 - as a subscript [[expr.sub]]
-- as an argument to a constructor invocation ([[dcl.init]],
-  [[expr.type.conv]])
 - as an initializer for a non-static data member [[class.mem]]
 - in a *mem-initializer* [[class.base.init]]
 - on the right-hand side of an assignment [[expr.ass]]
 [*Example 1*:
@@ -1088,12 +1086,13 @@ initializer list as the argument to the constructor template
 `template<class T> C(T)` of a class `C` does not create an
 initializer-list constructor, because an initializer list argument
 causes the corresponding parameter to be a non-deduced context
 [[temp.deduct.call]]. — *end note*]
-The template `std::initializer_list` is not predefined; if the header
-`<initializer_list>` is not imported or included prior to a use of
 `std::initializer_list` — even an implicit use in which the type is not
 named [[dcl.spec.auto]] — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
@@ -1132,22 +1131,22 @@ follows:
     int m1;
     double m2, m3;
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
-  S2 s23 { };                         // OK: default to 0,0,0
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements and `T` is a class
   type with a default constructor, the object is value-initialized.
 - Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
   the object is constructed as described below.
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
-  through overload resolution ([[over.match]], [[over.match.list]]). If
- a narrowing conversion (see below) is required to convert any of the
   arguments, the program is ill-formed.
   \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
@@ -1176,13 +1175,13 @@ follows:
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
     // ...
   };
-  S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
-  S s3 { };                           // OK: invoke #2
   ```
   — *end example*]
 - Otherwise, if `T` is an enumeration with a fixed underlying type
   [[dcl.enum]] `U`, the *initializer-list* has a single element `v`, `v`
@@ -1223,32 +1222,32 @@ follows:
   int x2 {2.0};                       // error: narrowing
   ```
   — *end example*]
 - Otherwise, if `T` is a reference type, a prvalue is generated. The
-  prvalue initializes its result object by copy-list-initialization. The
-  prvalue is then used to direct-initialize the reference. The type of
-  the temporary is the type referenced by `T`, unless `T` is “reference
-  to array of unknown bound of `U`”, in which case the type of the
- temporary is the type of `x` in the declaration `U x[] H`, where H is
-  the initializer list.
   \[*Note 3*: As usual, the binding will fail and the program is
   ill-formed if the reference type is an lvalue reference to a non-const
   type. — *end note*]
   \[*Example 9*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   };
-  const S& r1 = { 1, 2, 3.0 };        // OK: invoke #1
-  const S& r2 { "Spinach" };          // OK: invoke #2
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
-  const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   struct A { } a;
   struct B { explicit B(const A&); };
   const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
   ```
@@ -1367,27 +1366,34 @@ variable, so the array persists for the lifetime of the variable. For
 member, so the program is ill-formed [[class.base.init]].
 — *end example*]
 [*Note 6*: The implementation is free to allocate the array in
-read-only memory if an explicit array with the same initializer could be
 so allocated. — *end note*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
-- from `long double` to `double` or `float`, or from `double` to
- `float`, except where the source is a constant expression and the
   actual value after conversion is within the range of values that can
   be represented (even if it cannot be represented exactly), or
 - from an integer type or unscoped enumeration type to a floating-point
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
-  where the source is a constant expression whose value after integral
     promotions will fit into the target type, or
 - from a pointer type or a pointer-to-member type to `bool`.
 [*Note 7*: As indicated above, such conversions are not allowed at the
 top level in list-initializations. — *end note*]
@@ -1396,24 +1402,24 @@ top level in list-initializations. — *end note*]
 ``` cpp
 int x = 999;                    // x is not a constant expression
 const int y = 999;
 const int z = 99;
-char c1 = x;                    // OK, though it might narrow (in this case, it does narrow)
-char c2{x};                     // error: might narrow
 char c3{y};                     // error: narrows (assuming char is 8 bits)
-char c4{z};                     // OK: no narrowing needed
-unsigned char uc1 = {5};        // OK: no narrowing needed
 unsigned char uc2 = {-1};       // error: narrows
 unsigned int ui1 = {-1};        // error: narrows
 signed int si1 =
   { (unsigned int)-1 };         // error: narrows
 int ii = {2.0};                 // error: narrows
-float f1 { x };                 // error: might narrow
-float f2 { 7 };                 // OK: 7 can be exactly represented as a float
 bool b = {"meow"};              // error: narrows
 int f(int);
-int a[] = { 2, f(2), f(2.0) };  // OK: the double-to-int conversion is not at the top level
 ```
 — *end example*]

 ## Initializers <a id="dcl.init">[[dcl.init]]</a>
+### General <a id="dcl.init.general">[[dcl.init.general]]</a>
+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.
 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
 [*Note 3*: The order of initialization of variables with static storage
 duration is described in  [[basic.start]] and
 [[stmt.dcl]]. — *end note*]
+A declaration D of a variable with linkage shall not have an
+*initializer* if D inhabits a block scope.
 To *zero-initialize* an object or reference of type `T` means:
+- if `T` is a scalar type [[term.scalar.type]], the object is
+ initialized to the value obtained by converting the integer literal
+  `0` (zero) to `T`;[^5]
 - if `T` is a (possibly cv-qualified) non-union class type, its padding
+  bits [[term.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;
 - if `T` is a (possibly cv-qualified) union type, its padding bits
+  [[term.padding.bits]] are initialized to zero bits and the object’s
+ first non-static named data member is zero-initialized;
 - if `T` is an array type, each element is zero-initialized;
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
 [*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.
 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 other than by a *designated-initializer-clause*
+[[dcl.init.aggr]], is called *copy-initialization*.
+[*Note 5*: Copy-initialization can invoke a move
 [[class.copy.ctor]]. — *end note*]
 The initialization that occurs
 - for an *initializer* that is a parenthesized *expression-list* or a
 - 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]].
 - If the initializer is `()`, the object is value-initialized.
+  \[*Note 6*:
+  Since `()` is not permitted by the syntax for *initializer*,
+  ``` cpp
+  X a();
+  ```
+  is not the declaration of an object of class `X`, but the declaration
+  of a function taking no arguments and returning an `X`. The form `()`
+  is permitted in certain other initialization contexts
+  [[expr.new]], [[expr.type.conv]], [[class.base.init]].
+  — *end note*]
 - Otherwise, if the destination type is an array, the object is
   initialized as follows. Let x₁, …, xₖ 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
 - Otherwise, if the destination type is a (possibly cv-qualified) class
   type:
   - 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 2*: `T x = T(T(T()));`
+ value-initializes `x`. — *end example*]
   - 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
       \[*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 3*:
       ``` cpp
       struct A {
         int a;
         int&& r;
       };
   int c = b;
   ```
   — *end note*]
+An immediate invocation [[expr.const]] that is not evaluated where it
+appears [[dcl.fct.default]], [[class.mem.general]] is evaluated and
+checked for whether it is a constant expression at the point where the
+enclosing *initializer* is used in a function call, a constructor
+definition, or an aggregate initialization.
 An *initializer-clause* followed by an ellipsis is a pack expansion
 [[temp.variadic]].
+Initialization includes the evaluation of all subexpressions of each
+*initializer-clause* of the initializer (possibly nested within
+*braced-init-list*s) and the creation of any temporary objects for
+function arguments or return values [[class.temporary]].
 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 *designator*s of a
 *designated-initializer-list*.
 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]] can be the
+declaration within the class definition and not the definition (if any)
+outside it. — *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 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:
 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 brace-enclosed
+ *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:
+- If the element is an anonymous union member and the initializer list
+  is a brace-enclosed *designated-initializer-list*, the element is
+  initialized by the *braced-init-list* `{ `*D*` }`, where *D* is the
+  *designated-initializer-clause* naming a member of the anonymous union
+ member. There shall be only one such *designated-initializer-clause*.
   \[*Example 1*:
   ``` cpp
   struct C {
     union {
       int a;
   *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*:
   ``` cpp
 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
 — *end example*]
 An array of unknown bound shall not be initialized with an empty
 *braced-init-list* `{}`.[^6]
+[*Note 5*:
 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
 — *end example*]
 — *end note*]
+[*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*:
 };                  // 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*:
 *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*:
 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.
 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*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 An array of ordinary character type [[basic.fundamental]], `char8_t`
+array, `char16_t` array, `char32_t` array, or `wchar_t` array may be
 initialized by an ordinary string literal, UTF-8 string literal, UTF-16
 string literal, UTF-32 string literal, or wide string literal,
 respectively, or by an appropriately-typed *string-literal* enclosed in
+braces [[lex.string]]. Additionally, an array of `char` or
+`unsigned char` may be initialized by a UTF-8 string literal, or by such
+a string literal enclosed in braces. Successive characters of the value
+of the *string-literal* initialize the elements of the array, with an
+integral conversion [[conv.integral]] if necessary for the source and
+destination value.
 [*Example 1*:
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 element not explicitly initialized shall be zero-initialized
 [[dcl.init]].
 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
+A variable whose declared type is “reference to `T`” [[dcl.ref]] shall
+be initialized.
 [*Example 1*:
 ``` cpp
 int g(int) noexcept;
     “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
     `T3`”[^7] (this conversion is selected by enumerating the applicable
     conversion functions [[over.match.ref]] and choosing the best one
     through overload resolution [[over.match]]),
+  then the reference binds to the initializer expression lvalue in the
+  first case and to the lvalue result of the conversion in the second
+  case (or, in either case, to the appropriate base class subobject of
+  the object).
   \[*Note 2*: The usual lvalue-to-rvalue [[conv.lval]], array-to-pointer
   [[conv.array]], and function-to-pointer [[conv.func]] standard
   conversions are not needed, and therefore are suppressed, when such
   direct bindings to lvalues are done. — *end note*]
   \[*Example 3*:
   - has a class type (i.e., `T2` is a class type), where `T1` is not
     reference-related to `T2`, and can be converted to an rvalue or
     function lvalue of type “*cv3* `T3`”, where “*cv1* `T1`” is
     reference-compatible with “*cv3* `T3`” (see  [[over.match.ref]]),
+  then the initializer expression in the first case and the converted
+ expression in the second case is called the converted initializer. If
+  the converted initializer is a prvalue, its type `T4` is adjusted to
+  type “*cv1* `T4`” [[conv.qual]] and the temporary materialization
+  conversion [[conv.rval]] is applied. In any case, the reference binds
+  to the resulting glvalue (or to an appropriate base class subobject).
   \[*Example 5*:
   ``` cpp
   struct A { };
   struct B : A { } b;
   extern B f();
+  const A& rca2 = f();                // binds to the A subobject of the B rvalue.
   A&& rra = f();                      // same as above
   struct X {
     operator B();
     operator int&();
   } x;
+  const A& r = x;                     // binds to the A subobject of the result of the conversion
   int i2 = 42;
+  int&& rri = static_cast<int&&>(i2); // binds directly to i2
+  B&& rrb = x;                        // binds directly to the result of operator B
   ```
   — *end example*]
 - Otherwise:
   - If `T1` or `T2` is a class type and `T1` is not reference-related to
     `T2`, user-defined conversions are considered using the rules for
     copy-initialization of an object of type “*cv1* `T1`” by
+    user-defined conversion
+    [[dcl.init]], [[over.match.copy]], [[over.match.conv]]; the program
+ is ill-formed if the corresponding non-reference copy-initialization
+ would be ill-formed. The result of the call to the conversion
+ function, as described for the non-reference copy-initialization, is
+ then used to direct-initialize the reference. For this
+ direct-initialization, user-defined conversions are not considered.
   - Otherwise, the initializer expression is implicitly converted to a
+    prvalue of type “`T1`”. The temporary materialization conversion is
+    applied, considering the type of the prvalue to be “*cv1* `T1`”, and
+    the reference is bound to the result.
   If `T1` is reference-related to `T2`:
   - *cv1* shall be the same cv-qualification as, or greater
     cv-qualification than, *cv2*; and
   - if the reference is an rvalue reference, the initializer expression
+    shall not be an lvalue. \[*Note 3*: This can be affected by whether
+    the initializer expression is move-eligible
+    [[expr.prim.id.unqual]]. — *end note*]
   \[*Example 6*:
   ``` cpp
   struct Banana { };
   struct Enigma { operator const Banana(); };
 In all cases except the last (i.e., implicitly converting the
 initializer expression to the referenced type), the reference is said to
 *bind directly* to the initializer expression.
+[*Note 4*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
 - as the initializer in a *new-expression* [[expr.new]]
 - in a `return` statement [[stmt.return]]
 - as a *for-range-initializer* [[stmt.iter]]
 - as a function argument [[expr.call]]
 - as a subscript [[expr.sub]]
+- as an argument to a constructor invocation
+  [[dcl.init]], [[expr.type.conv]]
 - as an initializer for a non-static data member [[class.mem]]
 - in a *mem-initializer* [[class.base.init]]
 - on the right-hand side of an assignment [[expr.ass]]
 [*Example 1*:
 `template<class T> C(T)` of a class `C` does not create an
 initializer-list constructor, because an initializer list argument
 causes the corresponding parameter to be a non-deduced context
 [[temp.deduct.call]]. — *end note*]
+The template `std::initializer_list` is not predefined; if a standard
+library declaration [[initializer.list.syn]], [[std.modules]] of
+`std::initializer_list` is not reachable from [[module.reach]] a use of
 `std::initializer_list` — even an implicit use in which the type is not
 named [[dcl.spec.auto]] — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
     int m1;
     double m2, m3;
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
+  S2 s23 { };                         // OK, default to 0,0,0
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements and `T` is a class
   type with a default constructor, the object is value-initialized.
 - Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
   the object is constructed as described below.
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
+  through overload resolution [[over.match]], [[over.match.list]]. If a
+  narrowing conversion (see below) is required to convert any of the
   arguments, the program is ill-formed.
   \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
     // ...
   };
+  S s1 = { 1, 2, 3.0 };               // OK, invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
+  S s3 { };                           // OK, invoke #2
   ```
   — *end example*]
 - Otherwise, if `T` is an enumeration with a fixed underlying type
   [[dcl.enum]] `U`, the *initializer-list* has a single element `v`, `v`
   int x2 {2.0};                       // error: narrowing
   ```
   — *end example*]
 - Otherwise, if `T` is a reference type, a prvalue is generated. The
+  prvalue initializes its result object by copy-list-initialization from
+ the initializer list. The prvalue is then used to direct-initialize
+  the reference. The type of the prvalue is the type referenced by `T`,
+ unless `T` is “reference to array of unknown bound of `U`”, in which
+ case the type of the prvalue is the type of `x` in the declaration
+ `U x[] H`, where H is the initializer list.
   \[*Note 3*: As usual, the binding will fail and the program is
   ill-formed if the reference type is an lvalue reference to a non-const
   type. — *end note*]
   \[*Example 9*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   };
+  const S& r1 = { 1, 2, 3.0 };        // OK, invoke #1
+  const S& r2 { "Spinach" };          // OK, invoke #2
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
+  const int (&iar)[2] = { 1, 2 };     // OK, iar is bound to temporary array
   struct A { } a;
   struct B { explicit B(const A&); };
   const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
   ```
 member, so the program is ill-formed [[class.base.init]].
 — *end example*]
 [*Note 6*: The implementation is free to allocate the array in
+read-only memory if an explicit array with the same initializer can be
 so allocated. — *end note*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
+- from a floating-point type `T` to another floating-point type whose
+ floating-point conversion rank is neither greater than nor equal to
+  that of `T`, except where the source is a constant expression and the
   actual value after conversion is within the range of values that can
   be represented (even if it cannot be represented exactly), or
 - from an integer type or unscoped enumeration type to a floating-point
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
+  where
+  - the source is a bit-field whose width w is less than that of its
+    type (or, for an enumeration type, its underlying type) and the
+    target type can represent all the values of a hypothetical extended
+    integer type with width w and with the same signedness as the
+    original type or
+  - the source is a constant expression whose value after integral
     promotions will fit into the target type, or
 - from a pointer type or a pointer-to-member type to `bool`.
 [*Note 7*: As indicated above, such conversions are not allowed at the
 top level in list-initializations. — *end note*]
 ``` cpp
 int x = 999;                    // x is not a constant expression
 const int y = 999;
 const int z = 99;
+char c1 = x;                    // OK, though it potentially narrows (in this case, it does narrow)
+char c2{x};                     // error: potentially narrows
 char c3{y};                     // error: narrows (assuming char is 8 bits)
+char c4{z};                     // OK, no narrowing needed
+unsigned char uc1 = {5};        // OK, no narrowing needed
 unsigned char uc2 = {-1};       // error: narrows
 unsigned int ui1 = {-1};        // error: narrows
 signed int si1 =
   { (unsigned int)-1 };         // error: narrows
 int ii = {2.0};                 // error: narrows
+float f1 { x };                 // error: potentially narrows
+float f2 { 7 };                 // OK, 7 can be exactly represented as a float
 bool b = {"meow"};              // error: narrows
 int f(int);
+int a[] = { 2, f(2), f(2.0) };  // OK, the double-to-int conversion is not at the top level
 ```
 — *end example*]

Diff to HTML by rtfpessoa