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

Files changed (1) hide show

tmp/tmp14wq0vx5/{from.md → to.md} +86 -310

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

@@ -1,32 +1,33 @@
 ### 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};
@@ -42,43 +43,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 {
@@ -95,14 +110,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
@@ -112,20 +127,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
@@ -135,17 +150,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
@@ -168,26 +183,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
     // ...
@@ -196,23 +213,27 @@ 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 {
@@ -231,13 +252,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
@@ -245,25 +266,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);
 };
@@ -281,16 +302,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 };
@@ -309,11 +330,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
@@ -331,16 +352,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;
@@ -354,258 +376,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.

 ### 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 {
   ```
   — *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