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

Files changed (1) hide show

tmp/tmpt7fp76bl/{from.md → to.md} +480 -627

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

@@ -1,13 +1,12 @@
 ## Initializers <a id="dcl.init">[[dcl.init]]</a>
-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 ')'
@@ -23,28 +22,49 @@ brace-or-equal-initializer:
 initializer-clause:
     assignment-expression
     braced-init-list
 ```
-``` bnf
-initializer-list:
-    initializer-clause '...'ₒₚₜ
-    initializer-list ',' initializer-clause '...'ₒₚₜ
-```
 ``` bnf
 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.
@@ -58,43 +78,44 @@ 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
@@ -115,105 +136,53 @@ 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
- constructor that is user-provided or deleted, then the object is
- default-initialized;
-- if `T` is a (possibly cv-qualified) class type without a user-provided
-  or deleted default constructor, then the object is zero-initialized
-  and the semantic constraints for default-initialization are checked,
-  and if `T` has a non-trivial default constructor, the object is
-  default-initialized;
 - 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 {
@@ -230,164 +199,252 @@ int X::b = a;                   // X::b = X::a
 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
- initialization is ill-formed.
   - Otherwise (i.e., for the remaining copy-initialization cases),
-    user-defined conversion sequences that can convert from the source
- type to the destination type or (when a conversion function is used)
- to a derived class thereof are enumerated as described in
     [[over.match.copy]], and the best one is chosen through overload
-    resolution ([[over.match]]). If the conversion cannot be done or is
     ambiguous, the initialization is ill-formed. The function selected
     is called with the initializer expression as its argument; if the
     function is a constructor, the call is a prvalue of the
     cv-unqualified version of the destination type whose result object
     is initialized by the constructor. The call is used to
     direct-initialize, according to the rules above, the object that is
     the destination of the copy-initialization.
 - Otherwise, if the source type is a (possibly cv-qualified) class type,
   conversion functions are considered. The applicable conversion
-  functions are enumerated ([[over.match.conv]]), and the best one is
-  chosen through overload resolution ([[over.match]]). The user-defined
   conversion so selected is called to convert the initializer expression
   into the object being initialized. If the conversion cannot be done or
   is ambiguous, the initialization is ill-formed.
 - 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 {
       int i;
@@ -395,11 +452,10 @@ struct A {
     } 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;
@@ -412,46 +468,109 @@ struct derived : base1, base2 {
   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
 };
@@ -459,16 +578,16 @@ struct S {
 — *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;
@@ -485,86 +604,51 @@ 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" };
-```
-initializes `ss.a` with 1, `ss.b` with `"asdf"`, `ss.c` with the value
-of an expression of the form `int{}` (that is, `0`), and `ss.d` with the
-value of `ss.b[ss.a]` (that is, `'s'`), and in
-``` cpp
-struct X { int i, j, k = 42; };
-X a[] = { 1, 2, 3, 4, 5, 6 };
-X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
-```
-`a` and `b` have the same value
-— *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;
@@ -583,13 +667,13 @@ struct A {
 — *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 };
 ```
@@ -616,11 +700,11 @@ 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 },
@@ -648,22 +732,22 @@ 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();
@@ -680,49 +764,50 @@ 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
-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.
 [*Example 1*:
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
@@ -745,16 +830,16 @@ 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
@@ -777,19 +862,19 @@ void f() {
 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
@@ -797,48 +882,41 @@ 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
@@ -849,36 +927,36 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   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();
@@ -894,41 +972,40 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   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;
@@ -945,43 +1022,44 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   ```
   — *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*,
-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*.
 [*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};
@@ -997,43 +1075,57 @@ 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 {
@@ -1050,14 +1142,14 @@ follows:
   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
@@ -1067,20 +1159,20 @@ follows:
   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
@@ -1090,17 +1182,17 @@ follows:
   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
@@ -1123,26 +1215,28 @@ follows:
   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
     // ...
@@ -1151,24 +1245,28 @@ follows:
   const S& r2 { "Spinach" };          // OK: invoke #2
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
   — *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 {
     B(std::initializer_list<int>);
@@ -1186,13 +1284,13 @@ follows:
   ```
   — *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
@@ -1200,25 +1298,25 @@ 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);
 };
@@ -1236,16 +1334,16 @@ X x(std::initializer_list<double>(__a, __a+3));
 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 };
@@ -1264,11 +1362,11 @@ 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
@@ -1286,16 +1384,17 @@ A *narrowing conversion* is an implicit conversion
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
   where the source is a constant expression whose value after integral
-  promotions will fit into the target type.
 [*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;
@@ -1309,258 +1408,12 @@ unsigned int ui1 = {-1};  // error: narrows
 signed int si1 =
   { (unsigned int)-1 };         // error: narrows
 int ii = {2.0};                 // error: narrows
 float f1 { x };                 // error: might narrow
 float f2 { 7 };                 // OK: 7 can be exactly represented as a float
 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.access]: class.md#class.access
-[class.base.init]: special.md#class.base.init
-[class.bit]: class.md#class.bit
-[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.fct.def]: #dcl.fct.def
-[dcl.fct.def.default]: #dcl.fct.def.default
-[dcl.fct.def.delete]: #dcl.fct.def.delete
-[dcl.fct.def.general]: #dcl.fct.def.general
-[dcl.fct.default]: #dcl.fct.default
-[dcl.fct.spec]: #dcl.fct.spec
-[dcl.friend]: #dcl.friend
-[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.ass]: expr.md#expr.ass
-[expr.call]: expr.md#expr.call
-[expr.cast]: expr.md#expr.cast
-[expr.comma]: expr.md#expr.comma
-[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
-[lex.key]: lex.md#lex.key
-[lex.name]: lex.md#lex.name
-[lex.string]: lex.md#lex.string
-[namespace.alias]: #namespace.alias
-[namespace.def]: #namespace.def
-[namespace.memdef]: #namespace.memdef
-[namespace.qual]: basic.md#namespace.qual
-[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.mem]: temp.md#temp.mem
-[temp.names]: temp.md#temp.names
-[temp.param]: temp.md#temp.param
-[temp.res]: temp.md#temp.res
-[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.

 ## Initializers <a id="dcl.init">[[dcl.init]]</a>
+The process of initialization described in this subclause applies to all
+initializations regardless of syntactic context, including the
+initialization of a function parameter [[expr.call]], the initialization
+of a return value [[stmt.return]], or when an initializer follows a
+declarator.
 ``` bnf
 initializer:
     brace-or-equal-initializer
     '(' expression-list ')'
 initializer-clause:
     assignment-expression
     braced-init-list
 ```
 ``` bnf
 braced-init-list:
     '{' initializer-list ','ₒₚₜ '}'
+    '{' designated-initializer-list ','ₒₚₜ '}'
     '{' '}'
 ```
+``` bnf
+initializer-list:
+    initializer-clause '...'ₒₚₜ
+    initializer-list ',' initializer-clause '...'ₒₚₜ
+```
+``` bnf
+designated-initializer-list:
+    designated-initializer-clause
+    designated-initializer-list ',' designated-initializer-clause
+```
+``` bnf
+designated-initializer-clause:
+    designator brace-or-equal-initializer
+```
+``` bnf
+designator:
+    '.' identifier
+```
 ``` bnf
 expr-or-braced-init-list:
     expression
     braced-init-list
 ```
+[*Note 1*: The rules in this subclause apply even if the grammar
+permits only the *brace-or-equal-initializer* form of *initializer* in a
+given context. — *end note*]
 Except for objects declared with the `constexpr` specifier, for which
 see  [[dcl.constexpr]], an *initializer* in the definition of a variable
 can consist of arbitrary expressions involving literals and previously
 declared variables and functions, regardless of the variable’s storage
 duration.
 int c(b);
 ```
 — *end example*]
+[*Note 2*: Default arguments are more restricted; see
 [[dcl.fct.default]]. — *end note*]
+[*Note 3*: The order of initialization of variables with static storage
 duration is described in  [[basic.start]] and
 [[stmt.dcl]]. — *end note*]
 A declaration of a block-scope variable with external or internal
 linkage that has an *initializer* is ill-formed.
 To *zero-initialize* an object or reference of type `T` means:
+- if `T` is a scalar type [[basic.types]], the object is initialized to
+  the value obtained by converting the integer literal `0` (zero) to
+  `T`;[^5]
+- if `T` is a (possibly cv-qualified) non-union class type, its padding
+ bits [[basic.types]] are initialized to zero bits and each non-static
+ data member, each non-virtual base class subobject, and, if the object
+  is not a base class subobject, each virtual base class subobject is
+  zero-initialized;
+- if `T` is a (possibly cv-qualified) union type, its padding bits
+ [[basic.types]] are initialized to zero bits and the object’s first
+  non-static named data member is zero-initialized;
 - if `T` is an array type, each element is zero-initialized;
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
+- If `T` is a (possibly cv-qualified) class type [[class]], constructors
+  are considered. The applicable constructors are enumerated
+  [[over.match.ctor]], and the best one for the *initializer* `()` is
+  chosen through overload resolution [[over.match]]. The constructor
+  thus selected is called, with an empty argument list, to initialize
+  the object.
 - 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
 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 [[class]], then
+ - if `T` has either no default constructor [[class.default.ctor]] or a
+    default constructor that is user-provided or deleted, then the
+    object is default-initialized;
+ - otherwise, the object is zero-initialized and the semantic
+    constraints for default-initialization are checked, and if `T` has a
+    non-trivial default constructor, the object is default-initialized;
 - 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 4*: For every object of static storage duration, static
+initialization [[basic.start.static]] is performed at program startup
+before any other initialization takes place. In some cases, additional
+initialization is done later. — *end note*]
 An object whose initializer is an empty set of parentheses, i.e., `()`,
 shall be value-initialized.
+[*Note 5*:
 Since `()` is not permitted by the syntax for *initializer*,
 ``` cpp
 X a();
 ```
 is not the declaration of an object of class `X`, but the declaration of
 a function taking no argument and returning an `X`. The form `()` is
+permitted in certain other initialization contexts ([[expr.new]],
 [[expr.type.conv]], [[class.base.init]]).
 — *end note*]
 If no initializer is specified for an object, the object is
+default-initialized.
 An initializer for a static member is in the scope of the member’s
 class.
+[*Example 2*:
 ``` cpp
 int a;
 struct X {
 If the entity being initialized does not have class type, the
 *expression-list* in a parenthesized initializer shall be a single
 expression.
 The initialization that occurs in the `=` form of a
+*brace-or-equal-initializer* or *condition* [[stmt.select]], as well as
+in argument passing, function return, throwing an exception
+[[except.throw]], handling an exception [[except.handle]], and aggregate
+member initialization [[dcl.init.aggr]], is called
 *copy-initialization*.
+[*Note 6*: Copy-initialization may invoke a move
+[[class.copy.ctor]]. — *end note*]
+The initialization that occurs
+- for an *initializer* that is a parenthesized *expression-list* or a
+  *braced-init-list*,
+- for a *new-initializer* [[expr.new]],
+- in a `static_cast` expression [[expr.static.cast]],
+- in a functional notation type conversion [[expr.type.conv]], and
+- in the *braced-init-list* form of a *condition*
 is called *direct-initialization*.
 The semantics of initializers are as follows. The *destination type* is
 the type of the object or reference being initialized and the *source
 type* is the type of the initializer expression. If the initializer is
 not a single (possibly parenthesized) expression, the source type is not
 defined.
 - 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
+  `char8_t`, an array of `char16_t`, an array of `char32_t`, or an array
+ of `wchar_t`, and the initializer is a *string-literal*, see
+  [[dcl.init.string]].
 - If the initializer is `()`, the object is value-initialized.
+- Otherwise, if the destination type is an array, the object is
+ initialized as follows. Let x₁, …, xₖ be the elements of the
+  *expression-list*. If the destination type is an array of unknown
+  bound, it is defined as having k elements. Let n denote the array size
+  after this potential adjustment. If k is greater than n, the program
+  is ill-formed. Otherwise, the iᵗʰ array element is copy-initialized
+  with xᵢ for each 1 ≤ i ≤ k, and value-initialized for each k < i ≤ n.
+  For each 1 ≤ i < j ≤ n, every value computation and side effect
+  associated with the initialization of the iᵗʰ element of the array is
+  sequenced before those associated with the initialization of the jᵗʰ
+  element.
+- Otherwise, if the destination type is a (possibly cv-qualified) class
+  type:
   - If the initializer expression is a prvalue and the cv-unqualified
     version of the source type is the same class as the class of the
     destination, the initializer expression is used to initialize the
+    destination object. \[*Example 3*: `T x = T(T(T()));` calls the `T`
     default constructor to initialize `x`. — *end example*]
   - Otherwise, if the initialization is direct-initialization, or if it
     is copy-initialization where the cv-unqualified version of the
     source type is the same class as, or a derived class of, the class
     of the destination, constructors are considered. The applicable
+    constructors are enumerated [[over.match.ctor]], and the best one is
+    chosen through overload resolution [[over.match]]. Then:
+ - If overload resolution is successful, the selected constructor is
+      called to initialize the object, with the initializer expression
+ or *expression-list* as its argument(s).
+ - Otherwise, if no constructor is viable, the destination type is an
+      aggregate class, and the initializer is a parenthesized
+      *expression-list*, the object is initialized as follows. Let e₁,
+      …, eₙ be the elements of the aggregate [[dcl.init.aggr]]. Let x₁,
+      …, xₖ be the elements of the *expression-list*. If k is greater
+      than n, the program is ill-formed. The element eᵢ is
+      copy-initialized with xᵢ for 1 ≤ i ≤ k. The remaining elements are
+      initialized with their default member initializers, if any, and
+      otherwise are value-initialized. For each 1 ≤ i < j ≤ n, every
+      value computation and side effect associated with the
+      initialization of eᵢ is sequenced before those associated with the
+      initialization of eⱼ.
+      \[*Note 7*:
+      By contrast with direct-list-initialization, narrowing conversions
+      [[dcl.init.list]] are permitted, designators are not permitted, a
+      temporary object bound to a reference does not have its lifetime
+      extended [[class.temporary]], and there is no brace elision.
+      \[*Example 4*:
+      ``` cpp
+      struct A {
+        int a;
+        int&& r;
+      };
+      int f();
+      int n = 10;
+      A a1{1, f()};                   // OK, lifetime is extended
+      A a2(1, f());                   // well-formed, but dangling reference
+      A a3{1.0, 1};                   // error: narrowing conversion
+      A a4(1.0, 1);                   // well-formed, but dangling reference
+      A a5(1.0, std::move(n));        // OK
+      ```
+      — *end example*]
+      — *end note*]
+    - Otherwise, the initialization is ill-formed.
   - Otherwise (i.e., for the remaining copy-initialization cases),
+    user-defined conversions that can convert from the source type to
+    the destination type or (when a conversion function is used) to a
+    derived class thereof are enumerated as described in
     [[over.match.copy]], and the best one is chosen through overload
+    resolution [[over.match]]. If the conversion cannot be done or is
     ambiguous, the initialization is ill-formed. The function selected
     is called with the initializer expression as its argument; if the
     function is a constructor, the call is a prvalue of the
     cv-unqualified version of the destination type whose result object
     is initialized by the constructor. The call is used to
     direct-initialize, according to the rules above, the object that is
     the destination of the copy-initialization.
 - Otherwise, if the source type is a (possibly cv-qualified) class type,
   conversion functions are considered. The applicable conversion
+  functions are enumerated [[over.match.conv]], and the best one is
+  chosen through overload resolution [[over.match]]. The user-defined
   conversion so selected is called to convert the initializer expression
   into the object being initialized. If the conversion cannot be done or
   is ambiguous, the initialization is ill-formed.
+- Otherwise, if the initialization is direct-initialization, the source
+  type is `std::nullptr_t`, and the destination type is `bool`, the
+  initial value of the object being initialized is `false`.
 - Otherwise, the initial value of the object being initialized is the
+  (possibly converted) value of the initializer expression. A standard
+ conversion sequence [[conv]] will be used, if necessary, to convert
   the initializer expression to the cv-unqualified version of the
   destination type; no user-defined conversions are considered. If the
   conversion cannot be done, the initialization is ill-formed. When
   initializing a bit-field with a value that it cannot represent, the
   resulting value of the bit-field is *implementation-defined*.
+  \[*Note 8*:
   An expression of type “*cv1* `T`” can initialize an object of type
   “*cv2* `T`” independently of the cv-qualifiers *cv1* and *cv2*.
   ``` 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]].
+The same *identifier* shall not appear in multiple *designator*s of a
+*designated-initializer-list*.
 An object whose initialization has completed is deemed to be
+constructed, even if the object is of non-class type or no constructor
+of the object’s class is invoked for the initialization.
+[*Note 9*: Such an object might have been value-initialized or
+initialized by aggregate initialization [[dcl.init.aggr]] or by an
+inherited constructor [[class.inhctor.init]]. — *end note*]
+Destroying an object of class type invokes the destructor of the class.
+Destroying a scalar type has no effect other than ending the lifetime of
+the object [[basic.life]]. Destroying an array destroys each element in
+reverse subscript order.
 A declaration that specifies the initialization of a variable, whether
 from an explicit initializer or by default-initialization, is called the
 *initializing declaration* of that variable.
+[*Note 10*: In most cases this is the defining declaration
+[[basic.def]] of the variable, but the initializing declaration of a
+non-inline static data member [[class.static.data]] might be the
 declaration within the class definition and not the definition at
 namespace scope. — *end note*]
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
+An *aggregate* is an array or a class [[class]] with
+- no user-declared or inherited constructors [[class.ctor]],
+- no private or protected direct non-static data members
+  [[class.access]],
+- no virtual functions [[class.virtual]], and
+- no virtual, private, or protected base classes [[class.mi]].
 [*Note 1*: Aggregate initialization does not allow accessing protected
 and private base class’ members or constructors. — *end note*]
 The *elements* of an aggregate are:
 - 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. The *explicitly
+initialized elements* of the aggregate are determined as follows:
+- If the initializer list is a *designated-initializer-list*, the
+  aggregate shall be of class type, the *identifier* in each
+  *designator* shall name a direct non-static data member of the class,
+  and the explicitly initialized elements of the aggregate are the
+  elements that are, or contain, those members.
+- If the initializer list is an *initializer-list*, the explicitly
+  initialized elements of the aggregate are the first n elements of the
+  aggregate, where n is the number of elements in the initializer list.
+- Otherwise, the initializer list must be `{}`, and there are no
+  explicitly initialized elements.
+For each explicitly initialized element:
+- If the element is an anonymous union object and the initializer list
+  is a *designated-initializer-list*, the anonymous union object is
+  initialized by the *designated-initializer-list* `{ `*D*` }`, where
+  *D* is the *designated-initializer-clause* naming a member of the
+  anonymous union object. There shall be only one such
+  *designated-initializer-clause*.
+  \[*Example 1*:
+  ``` cpp
+  struct C {
+    union {
+      int a;
+      const char* p;
+    };
+    int x;
+  } c = { .a = 1, .x = 3 };
+  ```
+  initializes `c.a` with 1 and `c.x` with 3.
+  — *end example*]
+- Otherwise, the element is copy-initialized from the corresponding
+  *initializer-clause* or is initialized with the
+  *brace-or-equal-initializer* of the corresponding
+  *designated-initializer-clause*. If that initializer is of the form
+  *assignment-expression* or `= `*assignment-expression* and a narrowing
+  conversion [[dcl.init.list]] is required to convert the expression,
+  the program is ill-formed.
+  \[*Note 2*: If an initializer is itself an initializer list, the
+  element is list-initialized, which will result in a recursive
+  application of the rules in this subclause if the element is an
   aggregate. — *end note*]
+  \[*Example 2*:
   ``` cpp
   struct A {
     int x;
     struct B {
       int i;
     } 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;
   derived d1{{1, 2}, {}, 4};
   derived d2{{}, {}, 4};
   ```
+ initializes `d1.b1` with 1, `d1.b2` with 2, `d1.b3` with 42, `d1.d`
+  with 4, and `d2.b1` with 0, `d2.b2` with 42, `d2.b3` with 42, `d2.d`
+  with 4.
+  — *end example*]
+For a non-union aggregate, each element that is not an explicitly
+initialized element is initialized as follows:
+- 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 3*:
+``` cpp
+struct S { int a; const char* b; int c; int d = b[a]; };
+S ss = { 1, "asdf" };
+```
+initializes `ss.a` with 1, `ss.b` with `"asdf"`, `ss.c` with the value
+of an expression of the form `int{}` (that is, `0`), and `ss.d` with the
+value of `ss.b[ss.a]` (that is, `'s'`), and in
+``` cpp
+struct X { int i, j, k = 42; };
+X a[] = { 1, 2, 3, 4, 5, 6 };
+X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
+```
+`a` and `b` have the same value
+``` cpp
+struct A {
+  string a;
+  int b = 42;
+  int c = -1;
+};
+```
+`A{.c=21}` has the following steps:
+- Initialize `a` with `{}`
+- Initialize `b` with `= 42`
+- Initialize `c` with `= 21`
 — *end example*]
+The initializations of the elements of the aggregate are evaluated in
+the element order. That is, all value computations and side effects
+associated with a given element are sequenced before those of any
+element that follows it in order.
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in  [[dcl.init]].
+The destructor for each element of class type is potentially invoked
+[[class.dtor]] from the context where the aggregate initialization
+occurs.
+[*Note 3*: This provision ensures that destructors can be called for
+fully-constructed subobjects in case an exception is thrown
+[[except.ctor]]. — *end note*]
 An array of unknown bound initialized with a brace-enclosed
+*initializer-list* containing `n` *initializer-clause*s is defined as
+having `n` elements [[dcl.array]].
+[*Example 4*:
 ``` 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 array of unknown bound shall not be initialized with an empty
+*braced-init-list* `{}`. [^6]
+[*Note 4*:
 A default member initializer does not determine the bound for a member
 array of unknown bound. Since the default member initializer is ignored
+if a suitable *mem-initializer* is present [[class.base.init]], the
 default member initializer is not considered to initialize the array of
 unknown bound.
+[*Example 5*:
 ``` cpp
 struct S {
   int y[] = { 0 };          // error: non-static data member of incomplete type
 };
 — *end example*]
 — *end note*]
+[*Note 5*:
+Static data members, non-static data members of anonymous union members,
+and unnamed bit-fields are not considered elements of the aggregate.
+[*Example 6*:
 ``` cpp
 struct A {
   int i;
   static int s;
 — *end example*]
 — *end note*]
 An *initializer-list* is ill-formed if the number of
+*initializer-clause*s exceeds the number of elements of the aggregate.
+[*Example 7*:
 ``` cpp
 char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
 ```
 is ill-formed.
 — *end example*]
+If a member has a default member initializer and a potentially-evaluated
+subexpression thereof is an aggregate initialization that would use that
+default member initializer, the program is ill-formed.
+[*Example 8*:
 ``` 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
+struct B {
+  int n = B{}.n;                // error
+};
 ```
 — *end example*]
 If an aggregate class `C` contains a subaggregate element `e` with no
 elements, the *initializer-clause* for `e` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
 *initializer-clause*s for all elements of `C` following `e` are also
 omitted.
+[*Example 9*:
 ``` cpp
 struct S { } s;
 struct A {
   S s1;
 — *end example*]
 When initializing a multi-dimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
+varying the fastest [[dcl.array]].
+[*Example 10*:
 ``` cpp
 int x[2][2] = { 3, 1, 4, 2 };
 ```
 *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 11*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
 does not, therefore three elements from the list are used. Likewise the
 next three are taken successively for `y[1]` and `y[2]`.
 — *end example*]
+All implicit type conversions [[conv]] are considered when initializing
+the element with an *assignment-expression*. If the
 *assignment-expression* can initialize an element, the element is
 initialized. Otherwise, if the element is itself a subaggregate, brace
 elision is assumed and the *assignment-expression* is considered for the
 initialization of the first element of the subaggregate.
+[*Note 6*: As specified above, brace elision cannot apply to
 subaggregates with no elements; an *initializer-clause* for the entire
 subobject is required. — *end note*]
+[*Example 12*:
 ``` cpp
 struct A {
   int i;
   operator int();
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
 — *end example*]
+[*Note 7*: An aggregate array or an aggregate class may contain
+elements of a class type with a user-declared constructor
+[[class.ctor]]. Initialization of these aggregate objects is described
 in  [[class.expl.init]]. — *end note*]
+[*Note 8*: Whether the initialization of aggregates with static storage
 duration is static or dynamic is specified in  [[basic.start.static]],
 [[basic.start.dynamic]], and  [[stmt.dcl]]. — *end note*]
+When a union is initialized with an initializer list, there shall not be
+more than one explicitly initialized element.
+[*Example 13*:
 ``` 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
+u f = { .b = "asdf" };
+u g = { .a = 1, .b = "asdf" };  // error
 ```
 — *end example*]
+[*Note 9*: As described above, the braces around the
 *initializer-clause* for a union member can be omitted if the union is a
 member of another aggregate. — *end note*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
+An array of ordinary character type [[basic.fundamental]], `char8_t`
+array, `char16_t` array, `char32_t` array, or `wchar_t` array can be
+initialized by an ordinary string literal, UTF-8 string literal, UTF-16
+string literal, UTF-32 string literal, or wide string literal,
+respectively, or by an appropriately-typed *string-literal* enclosed in
+braces [[lex.string]]. Successive characters of the value of the
+*string-literal* initialize the elements of the array.
 [*Example 1*:
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 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
 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
 ```
 — *end example*]
 Given types “*cv1* `T1`” and “*cv2* `T2`”, “*cv1* `T1`” is
+*reference-related* to “*cv2* `T2`” if `T1` is similar [[conv.qual]] to
+`T2`, or `T1` is a base class of `T2`. “*cv1* `T1`” is
+*reference-compatible* with “*cv2* `T2`” if a prvalue of type “pointer
+to *cv2* `T2`” can be converted to the type “pointer to *cv1* `T1`” via
+a standard conversion sequence [[conv]]. In all cases where the
 reference-compatible relationship of two types is used to establish the
+validity of a reference binding and the standard conversion sequence
+would be ill-formed, a program that necessitates such a binding is
+ill-formed.
 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`”[^7] (this conversion is selected by enumerating the applicable
+    conversion functions [[over.match.ref]] and choosing the best one
+    through overload resolution [[over.match]]),
   then the reference is bound to the initializer expression lvalue in
   the first case and to the lvalue result of the conversion in the
   second case (or, in either case, to the appropriate base class
   subobject of the object).
+  \[*Note 2*: The usual lvalue-to-rvalue [[conv.lval]], array-to-pointer
+  [[conv.array]], and function-to-pointer [[conv.func]] standard
+  conversions are not needed, and therefore are suppressed, when such
+  direct bindings to lvalues are done. — *end note*]
   \[*Example 3*:
   ``` cpp
   double d = 2.0;
   double& rd = d;                 // rd refers to d
   const double& rcd = d;          // rcd refers to d
   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, if the reference is an lvalue reference to a type that is
+ not const-qualified or is volatile-qualified, the program is
+ ill-formed.
   \[*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*]
+- Otherwise, 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();
   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(); // error
+ Banana &&banana2 = Enigma();      // error
+ Banana &&banana3 = Alaska();      // error
   }
   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;
   ```
   — *end example*]
 In all cases except the last (i.e., implicitly converting the
+initializer expression to the referenced type), the reference is said to
+*bind directly* to the initializer expression.
 [*Note 3*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
 *braced-init-list*. Such an initializer is called an *initializer list*,
+and the comma-separated *initializer-clause*s of the *initializer-list*
+or *designated-initializer-clause*s of the *designated-initializer-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*.
 [*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};
 — *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
+cv `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 imported or included prior to a use of
 `std::initializer_list` — even an implicit use in which the type is not
+named [[dcl.spec.auto]] — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
+- If the *braced-init-list* contains a *designated-initializer-list*,
+  `T` shall be an aggregate class. The ordered *identifier*s in the
+  *designator*s of the *designated-initializer-list* shall form a
+  subsequence of the ordered *identifier*s in the direct non-static data
+  members of `T`. Aggregate initialization is performed
+  [[dcl.init.aggr]].
+  \[*Example 2*:
+  ``` cpp
+  struct A { int x; int y; int z; };
+  A a{.y = 2, .x = 1};                // error: designator order does not match declaration order
+  A b{.x = 1, .z = 2};                // OK, b.y initialized to 0
+  ```
+  — *end example*]
 - 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
+ subclause.
 - Otherwise, if `T` is an aggregate, aggregate initialization is
+  performed [[dcl.init.aggr]].
+  \[*Example 3*:
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
   type with a default constructor, the object is value-initialized.
 - Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
   the object is constructed as described below.
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
+  through overload resolution ([[over.match]], [[over.match.list]]). If
+  a narrowing conversion (see below) is required to convert any of the
+  arguments, the program is ill-formed.
+  \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(std::initializer_list<int>);    // #2
     S();                              // #3
   S s2 = { 1, 2, 3 };                 // invoke #2
   S s3 = { };                         // invoke #3
   ```
   — *end example*]
+  \[*Example 5*:
   ``` cpp
   struct Map {
     Map(std::initializer_list<std::pair<std::string,int>>);
   };
   Map ship = {{"Sophie",14}, {"Surprise",28}};
   ```
   — *end example*]
+  \[*Example 6*:
   ``` cpp
   struct S {
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
   — *end example*]
+- Otherwise, if `T` is an enumeration with a fixed underlying type
+  [[dcl.enum]] `U`, the *initializer-list* has a single element `v`, `v`
+ can be implicitly converted to `U`, 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 `U`, the program is ill-formed.
+  \[*Example 7*:
   ``` cpp
   enum byte : unsigned char { };
   byte b { 42 };                      // OK
   byte c = { 42 };                    // error
   byte d = byte{ 42 };                // OK; same value as b
   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 8*:
   ``` cpp
   int x1 {2};                         // OK
   int x2 {2.0};                       // error: narrowing
   ```
   — *end example*]
+- Otherwise, if `T` is a reference type, a prvalue is generated. The
+  prvalue initializes its result object by copy-list-initialization. The
+ prvalue is then used to direct-initialize the reference. The type of
+ the temporary is the type referenced by `T`, unless `T` is “reference
+ to array of unknown bound of `U`”, in which case the type of the
+  temporary is the type of `x` in the declaration `U x[] H`, where H is
+  the initializer list.
   \[*Note 3*: As usual, the binding will fail and the program is
   ill-formed if the reference type is an lvalue reference to a non-const
   type. — *end note*]
+  \[*Example 9*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   const S& r2 { "Spinach" };          // OK: invoke #2
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
+  struct A { } a;
+  struct B { explicit B(const A&); };
+  const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   \[*Example 10*:
   ``` cpp
+  int** pp {};                        // initialized to null pointer
+  ```
+  — *end example*]
+- Otherwise, the program is ill-formed.
+  \[*Example 11*:
+  ``` cpp
   struct A { int i; int j; };
   A a1 { 1, 2 };                      // aggregate initialization
   A a2 { 1.2 };                       // error: narrowing
   struct B {
     B(std::initializer_list<int>);
   ```
   — *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
 *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
+is required to be accessible [[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 12*:
 ``` 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 13*:
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 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
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
   where the source is a constant expression whose value after integral
+  promotions will fit into the target type, or
+- from a pointer type or a pointer-to-member type to `bool`.
 [*Note 7*: As indicated above, such conversions are not allowed at the
 top level in list-initializations. — *end note*]
+[*Example 14*:
 ``` cpp
 int x = 999;                    // x is not a constant expression
 const int y = 999;
 const int z = 99;
 signed int si1 =
   { (unsigned int)-1 };         // error: narrows
 int ii = {2.0};                 // error: narrows
 float f1 { x };                 // error: might narrow
 float f2 { 7 };                 // OK: 7 can be exactly represented as a float
+bool b = {"meow"};              // error: narrows
 int f(int);
+int a[] = { 2, f(2), f(2.0) };  // OK: the double-to-int conversion is not at the top level
 ```
 — *end example*]

Diff to HTML by rtfpessoa