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

Files changed (1) hide show

tmp/tmpbtg9xd55/{from.md → to.md} +610 -307

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

@@ -2,13 +2,12 @@
 A declarator can specify an initial value for the identifier being
 declared. The identifier designates a variable being initialized. The
 process of initialization described in the remainder of  [[dcl.init]]
 applies also to initializations specified by other syntactic contexts,
-such as the initialization of function parameters with argument
-expressions ([[expr.call]]) or the initialization of return values (
-[[stmt.return]]).
 ``` bnf
 initializer:
     brace-or-equal-initializer
     '(' expression-list ')'
@@ -36,59 +35,87 @@ initializer-list:
 braced-init-list:
     '{' initializer-list ','ₒₚₜ '}'
     '{' '}'
 ```
 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.
 ``` cpp
 int f(int);
 int a = 2;
 int b = f(a);
 int c(b);
 ```
-Default arguments are more restricted; see  [[dcl.fct.default]].
-The order of initialization of variables with static storage duration is
-described in  [[basic.start]] and  [[stmt.dcl]].
 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`;[^14]
 - if `T` is a (possibly cv-qualified) non-union class type, each
-  non-static data member and each base-class subobject is
- zero-initialized and padding is initialized to zero bits;
 - if `T` is a (possibly cv-qualified) union type, the object’s first
   non-static named data member is zero-initialized and padding is
   initialized to zero bits;
 - 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:
-- if `T` is a (possibly cv-qualified) class type (Clause  [[class]]),
- the default constructor ([[class.ctor]]) for `T` is called (and the
- initialization is ill-formed if `T` has no default constructor or
- overload resolution ([[over.match]]) results in an ambiguity or in a
- function that is deleted or inaccessible from the context of the
- initialization);
-- if `T` is an array type, each element is default-initialized;
-- otherwise, no initialization is performed.
-If a program calls for the default initialization of an object of a
-const-qualified type `T`, `T` shall be a class type with a user-provided
-default constructor.
 To *value-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]])
   with either no default constructor ([[class.ctor]]) or a default
@@ -100,26 +127,22 @@ To *value-initialize* an object of type `T` means:
   and if `T` has a non-trivial default constructor, the object is
   default-initialized;
 - if `T` is an array type, then each element is value-initialized;
 - otherwise, the object is zero-initialized.
-An object that is value-initialized is deemed to be constructed and thus
-subject to provisions of this International Standard applying to
-“constructed” objects, objects “for which the constructor has
-completed,” etc., even if no constructor is invoked for the object’s
-initialization.
 A program that calls for default-initialization or value-initialization
 of an entity of reference type is ill-formed.
-Every object of static storage duration is zero-initialized at program
-startup before any other initialization takes place. In some cases,
-additional initialization is done later.
 An object whose initializer is an empty set of parentheses, i.e., `()`,
 shall be value-initialized.
 Since `()` is not permitted by the syntax for *initializer*,
 ``` cpp
 X a();
 ```
@@ -127,53 +150,71 @@ 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]]).
 If no initializer is specified for an object, the object is
 default-initialized. When storage for an object with automatic or
 dynamic storage duration is obtained, the object has an *indeterminate
 value*, and if no initialization is performed for the object, that
 object retains an indeterminate value until that value is replaced (
-[[expr.ass]]). Objects with static or thread storage duration are
-zero-initialized, see  [[basic.start.init]]. If an indeterminate value
-is produced by an evaluation, the behavior is undefined except in the
-following cases:
 - If an indeterminate value of unsigned narrow character type (
-  [[basic.fundamental]]) is produced by the evaluation of:
   - the second or third operand of a conditional expression (
     [[expr.cond]]),
   - the right operand of a comma expression ([[expr.comma]]),
-  - the operand of a cast or conversion to an unsigned narrow character
- type ([[conv.integral]], [[expr.type.conv]], [[expr.static.cast]],
- [[expr.cast]]), or
   - a discarded-value expression (Clause  [[expr]]),
   then the result of the operation is an indeterminate value.
-- If an indeterminate value of unsigned narrow character type is
-  produced by the evaluation of the right operand of a simple assignment
-  operator ([[expr.ass]]) whose first operand is an lvalue of unsigned
-  narrow character type, an indeterminate value replaces the value of
-  the object referred to by the left operand.
 - If an indeterminate value of unsigned narrow character type is
   produced by the evaluation of the initialization expression when
   initializing an object of unsigned narrow character type, that object
   is initialized to an indeterminate value.
 ``` cpp
   int f(bool b) {
     unsigned char c;
     unsigned char d = c;        // OK, d has an indeterminate value
     int e = d;                  // undefined behavior
     return b ? d : 0;           // undefined behavior if b is true
   }
 ```
 An initializer for a static member is in the scope of the member’s
 class.
 ``` cpp
 int a;
 struct X {
   static int a;
@@ -182,60 +223,65 @@ struct X {
 int X::a = 1;
 int X::b = a;                   // X::b = X::a
 ```
-The form of initialization (using parentheses or `=`) is generally
-insignificant, but does matter when the initializer or the entity being
-initialized has a class type; see below. 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
-``` cpp
-T x = a;
-```
-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*. Copy-initialization may invoke a move (
-[[class.copy]]).
 The initialization that occurs in the forms
 ``` cpp
 T x(a);
 T x{a};
 ```
-as well as in `new` expressions ([[expr.new]]), `static_cast`
-expressions ([[expr.static.cast]]), functional notation type
-conversions ([[expr.type.conv]]), and base and member initializers (
-[[class.base.init]]) 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.
-- If the initializer is a (non-parenthesized) *braced-init-list*, the
-  object or reference is list-initialized ([[dcl.init.list]]).
 - If the destination type is a reference type, see  [[dcl.init.ref]].
 - If the destination type is an array of characters, 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 program is
   ill-formed.
 - If the destination type is a (possibly cv-qualified) class type:
-  - 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]]). The
     constructor so selected is called to initialize the object, with the
     initializer expression or *expression-list* as its argument(s). If
     no constructor applies, or the overload resolution is ambiguous, the
@@ -246,20 +292,15 @@ defined.
     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 initializes a temporary of the
-    cv-unqualified version of the destination type. The temporary is a
- prvalue. The result of the call (which is the temporary for the
- constructor case) is then used to direct-initialize, according to
-    the rules above, the object that is the destination of the
-    copy-initialization. In certain cases, an implementation is
-    permitted to eliminate the copying inherent in this
-    direct-initialization by constructing the intermediate result
-    directly into the object being initialized; see
-    [[class.temporary]], [[class.copy]].
 - 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
@@ -268,40 +309,84 @@ defined.
 - Otherwise, the initial value of the object being initialized is the
   (possibly converted) value of the initializer expression. Standard
   conversions (Clause  [[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. An
- expression of type “ `T`” can initialize an object of type “ `T`”
- independently of the cv-qualifiers and .
   ``` cpp
   int a;
   const int b = a;
   int c = b;
   ```
 An *initializer-clause* followed by an ellipsis is a pack expansion (
 [[temp.variadic]]).
 ### 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 {
@@ -311,29 +396,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;
@@ -343,27 +478,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" };
 ```
@@ -378,17 +533,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;
@@ -402,17 +579,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
@@ -425,20 +603,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 },
@@ -464,19 +646,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();
@@ -491,34 +678,41 @@ 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.
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 An array of narrow character type ([[basic.fundamental]]), `char16_t`
 array, `char32_t` array, or `wchar_t` array can be initialized by a
@@ -526,38 +720,47 @@ narrow string literal, `char16_t` string literal, `char32_t` 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.
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 ```
 shows a character array whose members are initialized with a
 *string-literal*. Note that because `'\n'` is a single character and
 because a trailing `'\0'` is appended, `sizeof(msg)` is `25`.
 There shall not be more initializers than there are array elements.
 ``` cpp
 char cv[4] = "asdf";            // error
 ```
 is ill-formed since there is no space for the implied trailing `'\0'`.
 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 declared to be a `T&` or `T&&`, that is, “reference to type
-`T`” ([[dcl.ref]]), shall be initialized by an object, or function, of
-type `T` or by an object that can be converted into a `T`.
 ``` cpp
-int g(int);
 void f() {
   int i;
   int& r = i;                   // r refers to i
   r = 1;                        // the value of i becomes 1
   int* p = &r;                  // p points to i
@@ -568,56 +771,75 @@ void f() {
   int (&ra)[3] = a;             // ra refers to the array a
   ra[1] = i;                    // modifies a[1]
 }
 ```
 A reference cannot be changed to refer to another object after
-initialization. Note that initialization of a reference is treated very
-differently from assignment to it. Argument passing ([[expr.call]]) and
-function value return ([[stmt.return]]) are initializations.
 The initializer can be omitted for a reference only in a parameter
 declaration ([[dcl.fct]]), in the declaration of a function return
 type, in the declaration of a class member within its class definition (
 [[class.mem]]), and where the `extern` specifier is explicitly used.
 ``` cpp
 int& r1;                        // error: initializer missing
 extern int& r2;                 // OK
 ```
-Given types “ `T1`” and “ `T2`,” “ `T1`” is to “ `T2`” if `T1` is the
-same type as `T2`, or `T1` is a base class of `T2`. “ `T1`” is with “
-`T2`” if `T1` is reference-related to `T2` and *cv1* is the same
-cv-qualification as, or greater cv-qualification than, *cv2*. In all
-cases where the reference-related or reference-compatible relationship
-of two types is used to establish the validity of a reference binding,
-and `T1` is a base class of `T2`, a program that necessitates such a
-binding is ill-formed if `T1` is an inaccessible (Clause
-[[class.access]]) or ambiguous ([[class.member.lookup]]) base class of
-`T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
-  - is an lvalue (but is not a bit-field), and “ `T1`” is
-    reference-compatible with “ `T2`,” or
   - 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 lvalue of type
-    “ `T3`,” where “ `T1`” is reference-compatible with “ `T3`”[^16]
-    (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). 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.
   ``` cpp
   double d = 2.0;
   double& rd = d;                 // rd refers to d
   const double& rcd = d;          // rcd refers to d
@@ -625,36 +847,39 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   struct B : A { operator int&(); } b;
   A& ra = b;                      // ra refers to A subobject in b
   const A& rca = b;               // rca refers to A subobject in b
   int& ir = B();                  // ir refers to the result of B::operator int&
   ```
 - Otherwise, the reference shall be an lvalue reference to a
   non-volatile const type (i.e., *cv1* shall be `const`), or the
   reference shall be an rvalue reference.
   ``` cpp
   double& rd2 = 2.0;              // error: not an lvalue and reference not const
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   - If the initializer expression
-    - is an xvalue (but not a bit-field), class prvalue, array prvalue
- or function lvalue and “*cv1* `T1`” is reference-compatible with
-      “*cv2* `T2`”, or
     - 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 xvalue,
- class prvalue, or function lvalue of type “*cv3* `T3`”, where
- “*cv1* `T1`” is reference-compatible with “*cv3* `T3`” (see
-      [[over.match.ref]]),
-    then the reference is bound to the value of the initializer
- expression in the first case and to the result of the conversion in
- the second case (or, in either case, to an appropriate base class
- subobject). In the second case, if the reference is an rvalue
- reference and the second standard conversion sequence of the
- user-defined conversion sequence includes an lvalue-to-rvalue
- conversion, the program is ill-formed.
     ``` cpp
     struct A { };
     struct B : A { } b;
     extern B f();
     const A& rca2 = f();                // bound to the A subobject of the B rvalue.
@@ -665,59 +890,70 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     } 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
-    int&& rri2 = X();                   // error: lvalue-to-rvalue conversion applied to the
-                                        // result of operator int&
     ```
   - Otherwise:
-    - If `T1` is a class type, user-defined conversions are considered
- using the rules for copy-initialization of an object of type “
-      `T1`” by user-defined conversion ([[dcl.init]],
-      [[over.match.copy]]); 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. The program is ill-formed if
- the direct-initialization does not result in a direct binding or
- if it involves a user-defined conversion.
-    - If `T1` is a non-class type, a temporary of type “ `T1`” is
- created and copy-initialized ([[dcl.init]]) from the initializer
- expression. The reference is then bound to the temporary.
     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.
     ``` cpp
     struct Banana { };
     struct Enigma { operator const Banana(); };
     void enigmatic() {
       typedef const Banana ConstBanana;
       Banana &&banana1 = ConstBanana(); // ill-formed
       Banana &&banana2 = Enigma();      // ill-formed
     }
     const double& rcd2 = 2;         // rcd2 refers to temporary with value 2.0
     double&& rrd = 2;               // rrd refers to temporary with value 2.0
     const volatile int cvi = 1;
-    const int& r2 = cvi;            // error: type qualifiers dropped
     double d2 = 1.0;
-    double&& rrd2 = d2;             // error: copying lvalue of related type
     int i3 = 2;
     double&& rrd3 = i3;             // rrd3 refers to temporary with value 2.0
     ```
-In all cases except the last (i.e., creating and initializing a
-temporary from the initializer expression), the reference is said to
-*bind directly* to the initializer expression.
-[[class.temporary]] describes the lifetime of temporaries bound to
-references.
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
 *braced-init-list*. Such an initializer is called an *initializer list*,
@@ -725,24 +961,30 @@ and the comma-separated *initializer-clause*s of the list are called the
 *elements* of the initializer list. An initializer list may be empty.
 List-initialization can occur in direct-initialization or
 copy-initialization contexts; list-initialization in a
 direct-initialization context is called *direct-list-initialization* and
 list-initialization in a copy-initialization context is called
-*copy-list-initialization*. List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
-- 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]])
 ``` cpp
 int a = {1};
 std::complex<double> z{1,2};
 new std::vector<std::string>{"once", "upon", "a", "time"};  // 4 string elements
 f( {"Nicholas","Annemarie"} );  // pass list of two elements
@@ -750,30 +992,48 @@ return { "Norah" };             // return list of one element
 int* e {};                      // initialization to zero / null pointer
 x = double{1};                  // explicitly construct a double
 std::map<std::string,int> anim = { {"bear",4}, {"cassowary",2}, {"tiger",7} };
 ```
 A constructor is an *initializer-list constructor* if its first
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
-arguments ([[dcl.fct.default]]). Initializer-list constructors are
-favored over other constructors in list-initialization (
-[[over.match.list]]). Passing an 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]]). The template `std::initializer_list` is
-not predefined; if the header `<initializer_list>` is not 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:
-- If `T` is an aggregate, aggregate initialization is performed (
- [[dcl.init.aggr]]).
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
@@ -782,22 +1042,22 @@ follows:
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
 - 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>`, a
- prvalue `initializer_list` object is constructed as described below
-  and used to initialize the object according to the rules for
-  initialization of an object from a class of the same type (
-  [[dcl.init]]).
 - 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.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(std::initializer_list<int>);    // #2
     S();                              // #3
@@ -806,17 +1066,21 @@ follows:
   S s1 = { 1.0, 2.0, 3.0 };           // invoke #1
   S s2 = { 1, 2, 3 };                 // invoke #2
   S s3 = { };                         // invoke #3
   ```
   ``` cpp
   struct Map {
     Map(std::initializer_list<std::pair<std::string,int>>);
   };
   Map ship = {{"Sophie",14}, {"Surprise",28}};
   ```
   ``` cpp
   struct S {
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
@@ -824,25 +1088,61 @@ follows:
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
 - Otherwise, if the initializer list has a single element of type `E`
   and either `T` is not a reference type or its referenced type is
   reference-related to `E`, the object or reference is initialized from
-  that element; if a narrowing conversion (see below) is required to
- convert the element to `T`, the program is ill-formed.
   ``` cpp
   int x1 {2};                         // OK
   int x2 {2.0};                       // error: narrowing
   ```
-- Otherwise, if `T` is a reference type, a prvalue temporary of the type
- referenced by `T` is copy-list-initialized or direct-list-initialized,
-  depending on the kind of initialization for the reference, and the
- reference is bound to that temporary. 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.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
@@ -852,16 +1152,22 @@ follows:
   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
   ```
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
 - Otherwise, the program is ill-formed.
   ``` cpp
   struct A { int i; int j; };
   A a1 { 1, 2 };                      // aggregate initialization
   A a2 { 1.2 };                       // error: narrowing
   struct B {
@@ -877,32 +1183,42 @@ follows:
   int j { 1 };                        // initialize to 1
   int k { };                          // initialize to 0
   ```
 Within the *initializer-list* of a *braced-init-list*, the
 *initializer-clause*s, including any that result from pack expansions (
 [[temp.variadic]]), are evaluated in the order in which they appear.
 That is, every value computation and side effect associated with a given
 *initializer-clause* is sequenced before every value computation and
 side effect associated with any *initializer-clause* that follows it in
-the comma-separated list of the *initializer-list*. This evaluation
-ordering holds regardless of the semantics of the initialization; for
-example, it applies when the elements of the *initializer-list* are
-interpreted as arguments of a constructor call, even though ordinarily
-there are no sequencing constraints on the arguments of a call.
 An object of type `std::initializer_list<E>` is constructed from an
-initializer list as if the implementation allocated a temporary array of
-N elements of type `const E`, where N is the number of elements in the
-initializer list. Each element of that array is copy-initialized with
-the corresponding element of the initializer list, and the
-`std::initializer_list<E>` object is constructed to refer to that array.
-A constructor or conversion function selected for the copy shall be
-accessible (Clause  [[class.access]]) in the context of the initializer
-list. If a narrowing conversion is required to initialize any of the
-elements, the program is ill-formed.
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
@@ -918,15 +1234,19 @@ X x(std::initializer_list<double>(__a, __a+3));
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
 The array has the same lifetime as any other temporary object (
 [[class.temporary]]), except that initializing an `initializer_list`
 object from the array extends the lifetime of the array exactly like
 binding a reference to a temporary.
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
@@ -934,24 +1254,27 @@ void f() {
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
 struct A {
   std::initializer_list<int> i4;
-  A() : i4{ 1, 2, 3 } {}  // creates an A with a dangling reference
 };
 ```
 For `v1` and `v2`, the `initializer_list` object is a parameter in a
 function call, so the array created for `{ 1, 2, 3 }` has
 full-expression lifetime. For `i3`, the `initializer_list` object is a
 variable, so the array persists for the lifetime of the variable. For
-`i4`, the `initializer_list` object is initialized in a constructor’s
-*ctor-initializer*, so the array persists only until the constructor
-exits, and so any use of the elements of `i4` after the constructor
-exits produces undefined behavior. The implementation is free to
-allocate the array in read-only memory if an explicit array with the
-same initializer could be so allocated.
 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
@@ -965,12 +1288,14 @@ A *narrowing conversion* is an implicit conversion
 - 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.
-As indicated above, such conversions are not allowed at the top level in
-list-initializations.
 ``` cpp
 int x = 999;              // x is not a constant expression
 const int y = 999;
 const int z = 99;
@@ -989,34 +1314,41 @@ float f2 { 7 };           // OK: 7 can be exactly represented as a float
 int f(int);
 int a[] =
   { 2, f(2), f(2.0) };    // OK: the double-to-int conversion is not at the top level
 ```
 <!-- Link reference definitions -->
 [basic.compound]: basic.md#basic.compound
 [basic.def]: basic.md#basic.def
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
-[basic.start.init]: basic.md#basic.start.init
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [basic.types]: basic.md#basic.types
 [class]: class.md#class
@@ -1026,43 +1358,49 @@ int a[] =
 [class.conv]: special.md#class.conv
 [class.conv.ctor]: special.md#class.conv.ctor
 [class.conv.fct]: special.md#class.conv.fct
 [class.copy]: special.md#class.copy
 [class.ctor]: special.md#class.ctor
-[class.derived]: class.md#class.derived
 [class.dtor]: special.md#class.dtor
 [class.expl.init]: special.md#class.expl.init
 [class.friend]: class.md#class.friend
-[class.inhctor]: special.md#class.inhctor
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
-[class.this]: class.md#class.this
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
 [conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [dcl.enum]: #dcl.enum
 [dcl.fct]: #dcl.fct
@@ -1076,25 +1414,28 @@ int a[] =
 [dcl.init]: #dcl.init
 [dcl.init.aggr]: #dcl.init.aggr
 [dcl.init.list]: #dcl.init.list
 [dcl.init.ref]: #dcl.init.ref
 [dcl.init.string]: #dcl.init.string
 [dcl.link]: #dcl.link
 [dcl.meaning]: #dcl.meaning
 [dcl.mptr]: #dcl.mptr
 [dcl.name]: #dcl.name
 [dcl.ptr]: #dcl.ptr
 [dcl.ref]: #dcl.ref
 [dcl.spec]: #dcl.spec
 [dcl.spec.auto]: #dcl.spec.auto
 [dcl.stc]: #dcl.stc
 [dcl.type]: #dcl.type
 [dcl.type.cv]: #dcl.type.cv
 [dcl.type.elab]: #dcl.type.elab
 [dcl.type.simple]: #dcl.type.simple
 [dcl.typedef]: #dcl.typedef
-[depr.register]: future.md#depr.register
 [except.handle]: except.md#except.handle
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.alignof]: expr.md#expr.alignof
@@ -1105,18 +1446,18 @@ int a[] =
 [expr.cond]: expr.md#expr.cond
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
-[expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [expr.unary.op]: expr.md#expr.unary.op
-[global.names]: library.md#global.names
 [intro.compliance]: intro.md#intro.compliance
 [intro.execution]: intro.md#intro.execution
 [intro.multithread]: intro.md#intro.multithread
 [lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
@@ -1130,30 +1471,34 @@ int a[] =
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
 [over.match]: over.md#over.match
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
 [over.match.ref]: over.md#over.match.ref
 [over.oper]: over.md#over.oper
 [over.sub]: over.md#over.sub
 [stmt.ambig]: stmt.md#stmt.ambig
-[stmt.block]: stmt.md#stmt.block
 [stmt.dcl]: stmt.md#stmt.dcl
-[stmt.for]: stmt.md#stmt.for
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.return]: stmt.md#stmt.return
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.inst]: temp.md#temp.inst
@@ -1164,11 +1509,11 @@ int a[] =
 [temp.spec]: temp.md#temp.spec
 [temp.variadic]: temp.md#temp.variadic
 [^1]: The “implicit int” rule of C is no longer supported.
-[^2]: The inline keyword has no effect on the linkage of a function.
 [^3]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
@@ -1176,88 +1521,46 @@ int a[] =
 [^4]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
-[^5]: Although entities in an unnamed namespace might have external
-    linkage, they are effectively qualified by a name unique to their
-    translation unit and therefore can never be seen from any other
-    translation unit.
-[^6]: this implies that the name of the class or function is
     unqualified.
 [^7]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
-[^8]: A declaration with several declarators is usually equivalent to
-    the corresponding sequence of declarations each with a single
-    declarator. That is
-    `T  D1, D2, ... Dn;`
-    is usually equivalent to
-    `T  D1; T D2; ... T Dn;`
-    where `T` is a *decl-specifier-seq* and each `Di` is an
-    *init-declarator*. An exception occurs when a name introduced by one
-    of the *declarator*s hides a type name used by the
-    *decl-specifiers*, so that when the same *decl-specifiers* are used
-    in a subsequent declaration, they do not have the same meaning, as
-    in
-    `struct S { ... };`
-    `S S, T; \textrm{// declare two instances of \tcode{struct S}}`
-    which is not equivalent to
-    `struct S { ... };`
-    `S S;`
-    `S T; \textrm{// error}`
-    Another exception occurs when `T` is `auto` ([[dcl.spec.auto]]),
-    for example:
-    `auto i = 1, j = 2.0; \textrm{// error: deduced types for \tcode{i} and \tcode{j} do not match}`
-    as opposed to
-    `auto i = 1;    \textrm{// OK: \tcode{i} deduced to have type \tcode{int}}`
-    `auto j = 2.0;  \textrm{// OK: \tcode{j} deduced to have type \tcode{double}}`
-[^9]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
-[^10]: This excludes parameters of type “ `T2`” where `T2` is “pointer
-    to array of unknown bound of `T`” and where means any sequence of
-    “pointer to” and “array of” derived declarator types. This exclusion
-    applies to the parameters of the function, and if a parameter is a
-    pointer to function or pointer to member function then to its
-    parameters also, etc.
-[^11]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
-[^12]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
-[^13]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
-    [[global.names]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
-[^14]: As specified in  [[conv.ptr]], converting an integer literal
     whose value is `0` to a pointer type results in a null pointer
     value.
-[^15]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
-[^16]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

 A declarator can specify an initial value for the identifier being
 declared. The identifier designates a variable being initialized. The
 process of initialization described in the remainder of  [[dcl.init]]
 applies also to initializations specified by other syntactic contexts,
+such as the initialization of function parameters ([[expr.call]]) or
+the initialization of return values ([[stmt.return]]).
 ``` bnf
 initializer:
     brace-or-equal-initializer
     '(' expression-list ')'
 braced-init-list:
     '{' initializer-list ','ₒₚₜ '}'
     '{' '}'
 ```
+``` bnf
+expr-or-braced-init-list:
+    expression
+    braced-init-list
+```
 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*:
 ``` cpp
 int f(int);
 int a = 2;
 int b = f(a);
 int c(b);
 ```
+— *end example*]
+[*Note 1*: Default arguments are more restricted; see
+[[dcl.fct.default]]. — *end note*]
+[*Note 2*: 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`;[^12]
 - if `T` is a (possibly cv-qualified) non-union class type, 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 and padding is initialized to zero bits;
 - if `T` is a (possibly cv-qualified) union type, the object’s first
   non-static named data member is zero-initialized and padding is
   initialized to zero bits;
 - 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:
+- If `T` is a (possibly cv-qualified) class type (Clause  [[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.
+- If `T` is an array type, each element is default-initialized.
+- 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
+- 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,
+- if `T` is a union with at least one non-static data member, exactly
+  one variant member has a default member initializer,
+- 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
+- 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:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]])
   with either no default constructor ([[class.ctor]]) or a default
   and if `T` has a non-trivial default constructor, the object is
   default-initialized;
 - if `T` is an array type, then each element is value-initialized;
 - 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 3*: Every object of static storage duration is zero-initialized
+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 4*:
 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. When storage for an object with automatic or
 dynamic storage duration is obtained, the object has an *indeterminate
 value*, and if no initialization is performed for the object, that
 object retains an indeterminate value until that value is replaced (
+[[expr.ass]]).
+[*Note 5*: Objects with static or thread storage duration are
+zero-initialized, see  [[basic.start.static]]. — *end note*]
+If an indeterminate value is produced by an evaluation, the behavior is
+undefined except in the following cases:
 - If an indeterminate value of unsigned narrow character type (
+  [[basic.fundamental]]) or `std::byte` type ([[cstddef.syn]]) is
+  produced by the evaluation of:
   - the second or third operand of a conditional expression (
     [[expr.cond]]),
   - the right operand of a comma expression ([[expr.comma]]),
+  - the operand of a cast or conversion ([[conv.integral]],
+    [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]]) to an
+ unsigned narrow character type or `std::byte` type (
+    [[cstddef.syn]]), or
   - a discarded-value expression (Clause  [[expr]]),
   then the result of the operation is an indeterminate value.
+- If an indeterminate value of unsigned narrow character type or
+ `std::byte` type is produced by the evaluation of the right operand of
+ a simple assignment operator ([[expr.ass]]) whose first operand is an
+ lvalue of unsigned narrow character type or `std::byte` type, an
+ indeterminate value replaces the value of the object referred to by
+  the left operand.
 - If an indeterminate value of unsigned narrow character type is
   produced by the evaluation of the initialization expression when
   initializing an object of unsigned narrow character type, that object
   is initialized to an indeterminate value.
+- If an indeterminate value of unsigned narrow character type or
+  `std::byte` type is produced by the evaluation of the initialization
+  expression when initializing an object of `std::byte` type, that
+  object is initialized to an indeterminate value.
+[*Example 2*:
 ``` cpp
   int f(bool b) {
     unsigned char c;
     unsigned char d = c;        // OK, d has an indeterminate value
     int e = d;                  // undefined behavior
     return b ? d : 0;           // undefined behavior if b is true
   }
 ```
+— *end example*]
 An initializer for a static member is in the scope of the member’s
 class.
+[*Example 3*:
 ``` cpp
 int a;
 struct X {
   static int a;
 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]]). — *end note*]
 The initialization that occurs in the forms
 ``` cpp
 T x(a);
 T x{a};
 ```
+as well as in `new` expressions ([[expr.new]]), `static_cast`
+expressions ([[expr.static.cast]]), functional notation type
+conversions ([[expr.type.conv]]), *mem-initializer*s (
+[[class.base.init]]), and 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.
+- 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]]).
 - If the destination type is a reference type, see  [[dcl.init.ref]].
 - If the destination type is an array of characters, 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 program is
   ill-formed.
 - 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 4*: `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 chosen through overload resolution ([[over.match]]). The
     constructor so selected is called to initialize the object, with the
     initializer expression or *expression-list* as its argument(s). If
     no constructor applies, or the overload resolution is ambiguous, the
     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.
 - 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
 - Otherwise, the initial value of the object being initialized is the
   (possibly converted) value of the initializer expression. Standard
   conversions (Clause  [[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 7*:
+  An expression of type “*cv1* `T`” can initialize an object of type
+  “*cv2* `T`” independently of the cv-qualifiers *cv1* and *cv2*.
   ``` cpp
   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]]).
+An object whose initialization has completed is deemed to be
+constructed, even if no constructor of the object’s class is invoked for
+the initialization.
+[*Note 8*: 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*]
+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 9*: 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 (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*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 An array of narrow character type ([[basic.fundamental]]), `char16_t`
 array, `char32_t` array, or `wchar_t` array can be initialized by a
 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";
 ```
 shows a character array whose members are initialized with a
 *string-literal*. Note that because `'\n'` is a single character and
 because a trailing `'\0'` is appended, `sizeof(msg)` is `25`.
+— *end example*]
 There shall not be more initializers than there are array elements.
+[*Example 2*:
 ``` cpp
 char cv[4] = "asdf";            // error
 ```
 is ill-formed since there is no space for the implied trailing `'\0'`.
+— *end example*]
 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;
 void f() {
   int i;
   int& r = i;                   // r refers to i
   r = 1;                        // the value of i becomes 1
   int* p = &r;                  // p points to i
   int (&ra)[3] = a;             // ra refers to the array a
   ra[1] = i;                    // modifies a[1]
 }
 ```
+— *end example*]
 A reference cannot be changed to refer to another object after
+initialization.
+[*Note 1*: Assignment to a reference assigns to the object referred to
+by the reference ([[expr.ass]]). — *end note*]
+Argument passing ([[expr.call]]) and function value return (
+[[stmt.return]]) are initializations.
 The initializer can be omitted for a reference only in a parameter
 declaration ([[dcl.fct]]), in the declaration of a function return
 type, in the declaration of a class member within its class definition (
 [[class.mem]]), and where the `extern` specifier is explicitly used.
+[*Example 2*:
 ``` cpp
 int& r1;                        // error: initializer missing
 extern int& r2;                 // OK
 ```
+— *end example*]
+Given types “*cv1* `T1`” and “*cv2* `T2`”, “*cv1* `T1`” is
+*reference-related* to “*cv2* `T2`” if `T1` is the same type as `T2`, or
+`T1` is a base class of `T2`. “*cv1* `T1`” is *reference-compatible*
+with “*cv2* `T2`” if
+- `T1` is reference-related to `T2`, or
+- `T2` is “`noexcept` function” and `T1` is “function”, where the
+  function types are otherwise the same,
+and *cv1* is the same cv-qualification as, or greater cv-qualification
+than, *cv2*. In all cases where the reference-related or
+reference-compatible relationship of two types is used to establish the
+validity of a reference binding, and `T1` is a base class of `T2`, a
+program that necessitates such a binding is ill-formed if `T1` is an
+inaccessible (Clause  [[class.access]]) or ambiguous (
+[[class.member.lookup]]) base class of `T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
+  - is an lvalue (but is not a bit-field), and “*cv1* `T1`” is
+    reference-compatible with “*cv2* `T2`”, or
   - 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 lvalue of type
+    “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
+ `T3`”[^14] (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*:
   ``` cpp
   double d = 2.0;
   double& rd = d;                 // rd refers to d
   const double& rcd = d;          // rcd refers to d
   struct B : A { operator int&(); } b;
   A& ra = b;                      // ra refers to A subobject in b
   const A& rca = b;               // rca refers to A subobject in b
   int& ir = B();                  // ir refers to the result of B::operator int&
   ```
+  — *end example*]
 - Otherwise, the reference shall be an lvalue reference to a
   non-volatile const type (i.e., *cv1* shall be `const`), or the
   reference shall be an rvalue reference.
+  \[*Example 4*:
   ``` cpp
   double& rd2 = 2.0;              // error: not an lvalue and reference not const
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
+  — *end example*]
   - If the initializer expression
+    - is an rvalue (but not a bit-field) or function lvalue and “*cv1*
+      `T1`” is reference-compatible with “*cv2* `T2`”, or
     - 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.
     } 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(); };
+    struct Alaska { operator Banana&(); };
     void enigmatic() {
       typedef const Banana ConstBanana;
       Banana &&banana1 = ConstBanana(); // ill-formed
       Banana &&banana2 = Enigma();      // ill-formed
+      Banana &&banana3 = Alaska();      // ill-formed
     }
     const double& rcd2 = 2;         // rcd2 refers to temporary with value 2.0
     double&& rrd = 2;               // rrd refers to temporary with value 2.0
     const volatile int cvi = 1;
+    const int& r2 = cvi;            // error: cv-qualifier dropped
+    struct A { operator volatile int&(); } a;
+    const int& r3 = a;              // error: cv-qualifier dropped
+                                    // from result of conversion function
     double d2 = 1.0;
+    double&& rrd2 = d2;             // error: initializer is lvalue of related type
+    struct X { operator int&(); };
+    int&& rri2 = X();               // error: result of conversion function is lvalue of related type
     int i3 = 2;
     double&& rrd3 = i3;             // rrd3 refers to temporary with value 2.0
     ```
+    — *end example*]
+In all cases except the last (i.e., implicitly converting the
+initializer expression to the underlying type of the reference), 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
 *braced-init-list*. Such an initializer is called an *initializer list*,
 *elements* of the initializer list. An initializer list may be empty.
 List-initialization can occur in direct-initialization or
 copy-initialization contexts; list-initialization in a
 direct-initialization context is called *direct-list-initialization* and
 list-initialization in a copy-initialization context is called
+*copy-list-initialization*.
+[*Note 1*:
+List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
+- 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*:
 ``` cpp
 int a = {1};
 std::complex<double> z{1,2};
 new std::vector<std::string>{"once", "upon", "a", "time"};  // 4 string elements
 f( {"Nicholas","Annemarie"} );  // pass list of two elements
 int* e {};                      // initialization to zero / null pointer
 x = double{1};                  // explicitly construct a double
 std::map<std::string,int> anim = { {"bear",4}, {"cassowary",2}, {"tiger",7} };
 ```
+— *end example*]
+— *end note*]
 A constructor is an *initializer-list constructor* if its first
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
+arguments ([[dcl.fct.default]]).
+[*Note 2*: Initializer-list constructors are favored over other
+constructors in list-initialization ([[over.match.list]]). Passing an
+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 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:
+- If `T` is an aggregate class and the initializer list has a single
+ element of type *cv* `U`, where `U` is `T` or a class derived from
+  `T`, the object is initialized from that element (by
+  copy-initialization for copy-list-initialization, or by
+  direct-initialization for direct-list-initialization).
+- Otherwise, if `T` is a character array and the initializer list has a
+  single element that is an appropriately-typed string literal (
+  [[dcl.init.string]]), initialization is performed as described in that
+  section.
+- Otherwise, if `T` is an aggregate, aggregate initialization is
+  performed ([[dcl.init.aggr]]).
+  \[*Example 2*:
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
   };
   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 3*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(std::initializer_list<int>);    // #2
     S();                              // #3
   S s1 = { 1.0, 2.0, 3.0 };           // invoke #1
   S s2 = { 1, 2, 3 };                 // invoke #2
   S s3 = { };                         // invoke #3
   ```
+  — *end example*]
+  \[*Example 4*:
   ``` cpp
   struct Map {
     Map(std::initializer_list<std::pair<std::string,int>>);
   };
   Map ship = {{"Sophie",14}, {"Surprise",28}};
   ```
+  — *end example*]
+  \[*Example 5*:
   ``` cpp
   struct S {
     // 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]]), the *initializer-list* has a single element `v`, and
+  the initialization is direct-list-initialization, the object is
+  initialized with the value `T(v)` ([[expr.type.conv]]); if a
+  narrowing conversion is required to convert `v` to the underlying type
+  of `T`, the program is ill-formed.
+  \[*Example 6*:
+  ``` cpp
+  enum byte : unsigned char { };
+  byte b { 42 };                      // OK
+  byte c = { 42 };                    // error
+  byte d = byte{ 42 };                // OK; same value as b
+  byte e { -1 };                      // error
+  struct A { byte b; };
+  A a1 = { { 42 } };                  // error
+  A a2 = { byte{ 42 } };              // OK
+  void f(byte);
+  f({ 42 });                          // error
+  enum class Handle : uint32_t { Invalid = 0 };
+  Handle h { 42 };                    // OK
+  ```
+  — *end example*]
 - Otherwise, if the initializer list has a single element of type `E`
   and either `T` is not a reference type or its referenced type is
   reference-related to `E`, the object or reference is initialized from
+  that element (by copy-initialization for copy-list-initialization, or
+ by direct-initialization for direct-list-initialization); if a
+  narrowing conversion (see below) is required to convert the element to
+  `T`, the program is ill-formed.
+  \[*Example 7*:
   ``` cpp
   int x1 {2};                         // OK
   int x2 {2.0};                       // error: narrowing
   ```
+ — *end example*]
+- Otherwise, if `T` is a reference type, a prvalue of the type
+ referenced by `T` is generated. The prvalue initializes its result
+ object by copy-list-initialization or direct-list-initialization,
+ depending on the kind of initialization for the reference. The prvalue
+  is then used to direct-initialize the reference.
+  \[*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 8*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #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
   ```
+  — *end example*]
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
+  \[*Example 9*:
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
+  — *end example*]
 - Otherwise, the program is ill-formed.
+  \[*Example 10*:
   ``` cpp
   struct A { int i; int j; };
   A a1 { 1, 2 };                      // aggregate initialization
   A a2 { 1.2 };                       // error: narrowing
   struct B {
   int j { 1 };                        // initialize to 1
   int k { };                          // initialize to 0
   ```
+  — *end example*]
 Within the *initializer-list* of a *braced-init-list*, the
 *initializer-clause*s, including any that result from pack expansions (
 [[temp.variadic]]), are evaluated in the order in which they appear.
 That is, every value computation and side effect associated with a given
 *initializer-clause* is sequenced before every value computation and
 side effect associated with any *initializer-clause* that follows it in
+the comma-separated list of the *initializer-list*.
+[*Note 4*: This evaluation ordering holds regardless of the semantics
+of the initialization; for example, it applies when the elements of the
+*initializer-list* are interpreted as arguments of a constructor call,
+even though ordinarily there are no sequencing constraints on the
+arguments of a call. — *end note*]
 An object of type `std::initializer_list<E>` is constructed from an
+initializer list as if the implementation generated and materialized (
+[[conv.rval]]) a prvalue of type “array of N `const E`”, where N is the
+number of elements in the initializer list. Each element of that array
+is copy-initialized with the corresponding element of the initializer
+list, and the `std::initializer_list<E>` object is constructed to refer
+to that array.
+[*Note 5*: A constructor or conversion function selected for the copy
+shall be accessible (Clause  [[class.access]]) in the context of the
+initializer list. — *end note*]
+If a narrowing conversion is required to initialize any of the elements,
+the program is ill-formed.
+[*Example 11*:
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
+— *end example*]
 The array has the same lifetime as any other temporary object (
 [[class.temporary]]), except that initializing an `initializer_list`
 object from the array extends the lifetime of the array exactly like
 binding a reference to a temporary.
+[*Example 12*:
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
 struct A {
   std::initializer_list<int> i4;
+  A() : i4{ 1, 2, 3 } {}  // ill-formed, would create a dangling reference
 };
 ```
 For `v1` and `v2`, the `initializer_list` object is a parameter in a
 function call, so the array created for `{ 1, 2, 3 }` has
 full-expression lifetime. For `i3`, the `initializer_list` object is a
 variable, so the array persists for the lifetime of the variable. For
+`i4`, the `initializer_list` object is initialized in the constructor’s
+*ctor-initializer* as if by binding a temporary array to a reference
+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
 - 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.
+[*Note 7*: As indicated above, such conversions are not allowed at the
+top level in list-initializations. — *end note*]
+[*Example 13*:
 ``` cpp
 int x = 999;              // x is not a constant expression
 const int y = 999;
 const int z = 99;
 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*]
 <!-- Link reference definitions -->
+[basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.def]: basic.md#basic.def
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
+[basic.lookup.classref]: basic.md#basic.lookup.classref
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
 [basic.scope.block]: basic.md#basic.scope.block
+[basic.scope.declarative]: basic.md#basic.scope.declarative
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
+[basic.start.dynamic]: basic.md#basic.start.dynamic
+[basic.start.static]: basic.md#basic.start.static
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
+[basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [basic.types]: basic.md#basic.types
 [class]: class.md#class
 [class.conv]: special.md#class.conv
 [class.conv.ctor]: special.md#class.conv.ctor
 [class.conv.fct]: special.md#class.conv.fct
 [class.copy]: special.md#class.copy
 [class.ctor]: special.md#class.ctor
 [class.dtor]: special.md#class.dtor
 [class.expl.init]: special.md#class.expl.init
 [class.friend]: class.md#class.friend
+[class.inhctor.init]: special.md#class.inhctor.init
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
+[class.mi]: class.md#class.mi
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
 [class.union]: class.md#class.union
+[class.union.anon]: class.md#class.union.anon
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
 [conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
+[conv.qual]: conv.md#conv.qual
+[conv.rval]: conv.md#conv.rval
+[cstddef.syn]: language.md#cstddef.syn
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.deprecated]: #dcl.attr.deprecated
+[dcl.attr.fallthrough]: #dcl.attr.fallthrough
 [dcl.attr.grammar]: #dcl.attr.grammar
+[dcl.attr.nodiscard]: #dcl.attr.nodiscard
 [dcl.attr.noreturn]: #dcl.attr.noreturn
+[dcl.attr.unused]: #dcl.attr.unused
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [dcl.enum]: #dcl.enum
 [dcl.fct]: #dcl.fct
 [dcl.init]: #dcl.init
 [dcl.init.aggr]: #dcl.init.aggr
 [dcl.init.list]: #dcl.init.list
 [dcl.init.ref]: #dcl.init.ref
 [dcl.init.string]: #dcl.init.string
+[dcl.inline]: #dcl.inline
 [dcl.link]: #dcl.link
 [dcl.meaning]: #dcl.meaning
 [dcl.mptr]: #dcl.mptr
 [dcl.name]: #dcl.name
 [dcl.ptr]: #dcl.ptr
 [dcl.ref]: #dcl.ref
 [dcl.spec]: #dcl.spec
 [dcl.spec.auto]: #dcl.spec.auto
 [dcl.stc]: #dcl.stc
+[dcl.struct.bind]: #dcl.struct.bind
 [dcl.type]: #dcl.type
+[dcl.type.auto.deduct]: #dcl.type.auto.deduct
+[dcl.type.class.deduct]: #dcl.type.class.deduct
 [dcl.type.cv]: #dcl.type.cv
 [dcl.type.elab]: #dcl.type.elab
 [dcl.type.simple]: #dcl.type.simple
 [dcl.typedef]: #dcl.typedef
 [except.handle]: except.md#except.handle
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.alignof]: expr.md#expr.alignof
 [expr.cond]: expr.md#expr.cond
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
+[expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
+[expr.prim.this]: expr.md#expr.prim.this
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [expr.unary.op]: expr.md#expr.unary.op
 [intro.compliance]: intro.md#intro.compliance
 [intro.execution]: intro.md#intro.execution
 [intro.multithread]: intro.md#intro.multithread
 [lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
 [over.match]: over.md#over.match
+[over.match.class.deduct]: over.md#over.match.class.deduct
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
 [over.match.ref]: over.md#over.match.ref
 [over.oper]: over.md#over.oper
 [over.sub]: over.md#over.sub
 [stmt.ambig]: stmt.md#stmt.ambig
 [stmt.dcl]: stmt.md#stmt.dcl
+[stmt.expr]: stmt.md#stmt.expr
+[stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
+[stmt.label]: stmt.md#stmt.label
 [stmt.return]: stmt.md#stmt.return
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
+[stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
+[temp.deduct]: temp.md#temp.deduct
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.inst]: temp.md#temp.inst
 [temp.spec]: temp.md#temp.spec
 [temp.variadic]: temp.md#temp.variadic
 [^1]: The “implicit int” rule of C is no longer supported.
+[^2]: The `inline` keyword has no effect on the linkage of a function.
 [^3]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
 [^4]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
+[^5]: this implies that the name of the class or function is
     unqualified.
+[^6]: A *using-declaration* with more than one *using-declarator* is
+    equivalent to a corresponding sequence of *using-declaration*s with
+    one *using-declarator* each.
 [^7]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
+[^8]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
+[^9]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
+[^10]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
+[^11]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
+    [[lex.name]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
+[^12]: As specified in  [[conv.ptr]], converting an integer literal
     whose value is `0` to a pointer type results in a null pointer
     value.
+[^13]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
+[^14]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

Diff to HTML by rtfpessoa