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

Files changed (1) hide show

tmp/tmpt774dk64/{from.md → to.md} +214 -131

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

@@ -54,15 +54,18 @@ int c(b);
 Default arguments are more restricted; see  [[dcl.fct.default]].
 The order of initialization of variables with static storage duration is
 described in  [[basic.start]] and  [[stmt.dcl]].
 To *zero-initialize* an object or reference of type `T` means:
-- if `T` is a scalar type ([[basic.types]]), the object is set to the
-  value `0` (zero), taken as an integral constant expression, converted
- to `T`;[^15]
 - if `T` is a (possibly cv-qualified) non-union class type, each
   non-static data member and each base-class subobject is
   zero-initialized and padding is initialized to zero bits;
 - if `T` is a (possibly cv-qualified) union type, the object’s first
   non-static named data member is zero-initialized and padding is
@@ -71,29 +74,33 @@ To *zero-initialize* an object or reference of type `T` means:
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]]),
-  the default constructor for `T` is called (and the initialization is
-  ill-formed if `T` has no accessible default constructor);
 - if `T` is an array type, each element is default-initialized;
 - otherwise, no initialization is performed.
 If a program calls for the default initialization of an object of a
 const-qualified type `T`, `T` shall be a class type with a user-provided
 default constructor.
 To *value-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]])
-  with a user-provided constructor ([[class.ctor]]), then the default
-  constructor for `T` is called (and the initialization is ill-formed if
- `T` has no accessible default constructor);
-- if `T` is a (possibly cv-qualified) non-union class type without a
- user-provided constructor, then the object is zero-initialized and, if
- `T`’s implicitly-declared default constructor is non-trivial, that
-  constructor is called.
 - if `T` is an array type, then each element is value-initialized;
 - otherwise, the object is zero-initialized.
 An object that is value-initialized is deemed to be constructed and thus
 subject to provisions of this International Standard applying to
@@ -121,14 +128,48 @@ is not the declaration of an object of class `X`, but the declaration of
 a function taking no argument and returning an `X`. The form `()` is
 permitted in certain other initialization contexts ([[expr.new]],
 [[expr.type.conv]], [[class.base.init]]).
 If no initializer is specified for an object, the object is
-default-initialized; if no initialization is performed, an object with
-automatic or dynamic storage duration has indeterminate value. Objects
-with static or thread storage duration are zero-initialized, see
-[[basic.start.init]].
 An initializer for a static member is in the scope of the member’s
 class.
 ``` cpp
@@ -242,15 +283,14 @@ An *initializer-clause* followed by an ellipsis is a pack expansion (
 [[temp.variadic]]).
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
 An *aggregate* is an array or a class (Clause  [[class]]) with no
-user-provided constructors ([[class.ctor]]), no
-*brace-or-equal-initializer*s for non-static data members (
-[[class.mem]]), no private or protected non-static data members (Clause
-[[class.access]]), no base classes (Clause  [[class.derived]]), and no
-virtual functions ([[class.virtual]]).
 When an aggregate is initialized by an initializer list, as specified
 in  [[dcl.init.list]], the elements of the initializer list are taken as
 initializers for the members of the aggregate, in increasing subscript
 or member order. Each member is copy-initialized from the corresponding
@@ -286,11 +326,11 @@ int x[] = { 1, 3, 5 };
 ```
 declares and initializes `x` as a one-dimensional array that has three
 elements since no size was specified and there are three initializers.
 An empty initializer list `{}` shall not be used as the
-*initializer-clause * for an array of unknown bound.[^16]
 Static data members and anonymous bit-fields are not considered members
 of the class for purposes of aggregate initialization.
 ``` cpp
@@ -317,20 +357,30 @@ char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
 is ill-formed.
 If there are fewer *initializer-clause*s in the list than there are
 members in the aggregate, then each member not explicitly initialized
-shall be initialized from an empty initializer list (
 [[dcl.init.list]]).
 ``` cpp
-struct S { int a; const char* b; int c; };
 S ss = { 1, "asdf" };
 ```
-initializes `ss.a` with 1, `ss.b` with `"asdf"`, and `ss.c` with the
-value of an expression of the form `int()`, that is, `0`.
 If an aggregate class `C` contains a subaggregate member `m` that has no
 members for purposes of aggregate initialization, the
 *initializer-clause* for `m` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
@@ -375,17 +425,11 @@ float y[4][3] = {
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
-In a declaration of the form
-``` cpp
-T x = { a };
-```
-braces can be elided in an *initializer-list* as follows.[^17] If the
 *initializer-list* begins with a left brace, then the succeeding
 comma-separated list of *initializer-clause*s initializes the members of
 a subaggregate; it is erroneous for there to be more
 *initializer-clause*s than members. If, however, the *initializer-list*
 for a subaggregate does not begin with a left brace, then only enough
@@ -474,17 +518,17 @@ As described above, the braces around the *initializer-clause* for a
 union member can be omitted if the union is a member of another
 aggregate.
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
-A `char` array (whether plain `char`, `signed` `char`, or `unsigned`
-`char`), `char16_t` array, `char32_t` array, or `wchar_t` array can be
-initialized by a narrow character literal, `char16_t` string literal,
-`char32_t` string literal, or wide string literal, respectively, or by
-an appropriately-typed string literal enclosed in braces. Successive
-characters of the value of the string literal initialize the elements of
-the array.
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 ```
@@ -542,33 +586,30 @@ extern int& r2;                 // OK
 ```
 Given types “ `T1`” and “ `T2`,” “ `T1`” is to “ `T2`” if `T1` is the
 same type as `T2`, or `T1` is a base class of `T2`. “ `T1`” is with “
 `T2`” if `T1` is reference-related to `T2` and *cv1* is the same
-cv-qualification as, or greater cv-qualification than, *cv2*. For
-purposes of overload resolution, cases for which *cv1* is greater
-cv-qualification than *cv2* are identified as
-*reference-compatible with added qualification* (see
-[[over.ics.rank]]). In all cases where the reference-related or
-reference-compatible relationship of two types is used to establish the
-validity of a reference binding, and `T1` is a base class of `T2`, a
-program that necessitates such a binding is ill-formed if `T1` is an
-inaccessible (Clause  [[class.access]]) or ambiguous (
-[[class.member.lookup]]) base class of `T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
   - is an lvalue (but is not a bit-field), and “ `T1`” is
     reference-compatible with “ `T2`,” or
   - has a class type (i.e., `T2` is a class type), where `T1` is not
-    reference-related to `T2`, and can be implicitly converted to an
- lvalue of type “ `T3`,” where “ `T1`” is reference-compatible with “
- `T3`”[^18] (this conversion is selected by enumerating the
- applicable conversion functions ([[over.match.ref]]) and choosing
- the best one through overload resolution ([[over.match]])),
   then the reference is bound to the initializer expression lvalue in
   the first case and to the lvalue result of the conversion in the
   second case (or, in either case, to the appropriate base class
   subobject of the object). The usual lvalue-to-rvalue ([[conv.lval]]),
@@ -594,16 +635,18 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   - If the initializer expression
-    - is an xvalue, class prvalue, array prvalue or function lvalue and
-      “*cv1* `T1`” is reference-compatible with “*cv2* `T2`”, or
     - has a class type (i.e., `T2` is a class type), where `T1` is not
-      reference-related to `T2`, and can be implicitly converted to an
- xvalue, class prvalue, or function lvalue of type “*cv3* `T3`”,
- where “*cv1* `T1`” is reference-compatible with “*cv3* `T3`”,
     then the reference is bound to the value of the initializer
     expression in the first case and to the result of the conversion in
     the second case (or, in either case, to an appropriate base class
     subobject). In the second case, if the reference is an rvalue
@@ -625,18 +668,40 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     int&& rri = static_cast<int&&>(i2); // bound directly to i2
     B&& rrb = x;                        // bound directly to the result of operator B
     int&& rri2 = X();                   // error: lvalue-to-rvalue conversion applied to the
                                         // result of operator int&
     ```
-  - Otherwise, a temporary of type “ `T1`” is created and initialized
- from the initializer expression using the rules for a non-reference
- copy-initialization ([[dcl.init]]). The reference is then bound to
-    the temporary. If `T1` is reference-related to `T2`, *cv1* shall be
- the same cv-qualification as, or greater cv-qualification than,
-    *cv2*. If `T1` is reference-related to `T2` and the reference is an
-    rvalue reference, the initializer expression shall not be an lvalue.
     ``` cpp
     const double& rcd2 = 2;         // rcd2 refers to temporary with value 2.0
     double&& rrd = 2;               // rrd refers to temporary with value 2.0
     const volatile int cvi = 1;
     const int& r2 = cvi;            // error: type qualifiers dropped
     double d2 = 1.0;
@@ -665,10 +730,11 @@ list-initialization in a copy-initialization context is called
 *copy-list-initialization*. List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
 - as the initializer in a new expression ([[expr.new]])
 - in a return statement ([[stmt.return]])
 - as a 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]])
@@ -690,22 +756,24 @@ A constructor is an *initializer-list constructor* if its first
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
 arguments ([[dcl.fct.default]]). Initializer-list constructors are
 favored over other constructors in list-initialization (
-[[over.match.list]]).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 the initializer list has no elements and `T` is a class type with a
- default constructor, the object is value-initialized.
-- Otherwise, if `T` is an aggregate, aggregate initialization is
-  performed ([[dcl.init.aggr]]).
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
@@ -714,13 +782,15 @@ follows:
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
-- Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
- an `initializer_list` object is constructed as described below and
-  used to initialize the object according to the rules for
   initialization of an object from a class of the same type (
   [[dcl.init]]).
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
   through overload resolution ([[over.match]],  [[over.match.list]]).
@@ -754,15 +824,25 @@ follows:
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
 - Otherwise, if `T` is a reference type, a prvalue temporary of the type
-  referenced by `T` is list-initialized, and the reference is bound to
- that temporary. As usual, the binding will fail and the program is
- ill-formed if the reference type is an lvalue reference to a non-const
-  type.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
@@ -772,18 +852,10 @@ follows:
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
-- Otherwise, if the initializer list has a single element, the object or
-  reference is initialized from that element; if a narrowing conversion
-  (see below) is required to convert the element to `T`, the program is
-  ill-formed.
-  ``` cpp
-  int x1 {2};                         // OK
-  int x2 {2.0};                       // error: narrowing
-  ```
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
@@ -818,17 +890,19 @@ ordering holds regardless of the semantics of the initialization; for
 example, it applies when the elements of the *initializer-list* are
 interpreted as arguments of a constructor call, even though ordinarily
 there are no sequencing constraints on the arguments of a call.
 An object of type `std::initializer_list<E>` is constructed from an
-initializer list as if the implementation allocated an array of N
-elements of type `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.
-If a narrowing conversion is required to initialize any of the elements,
-the program is ill-formed.
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
@@ -837,35 +911,47 @@ X x{ 1,2,3 };
 The initialization will be implemented in a way roughly equivalent to
 this:
 ``` cpp
-double __a[3] = {double{1}, double{2}, double{3}};
 X x(std::initializer_list<double>(__a, __a+3));
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
-The lifetime of the array is the same as that of the `initializer_list`
-object.
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
   std::vector<cmplx> v2{ 1, 2, 3 };
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
 ```
-For `v1` and `v2`, the `initializer_list` object and array created for
-`{ 1, 2, 3 }` have full-expression lifetime. For `i3`, the
-`initializer_list` object and array have automatic lifetime. The
-implementation is free to allocate the array in read-only memory if an
-explicit array with the same initializer could be so allocated.
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from `long double` to `double` or `float`, or from `double` to
@@ -876,13 +962,12 @@ A *narrowing conversion* is an implicit conversion
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
-  where the source is a constant expression and the actual value after
- conversion will fit into the target type and will produce the original
-  value when converted back to the original type.
 As indicated above, such conversions are not allowed at the top level in
 list-initializations.
 ``` cpp
@@ -920,12 +1005,13 @@ int a[] =
 [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.local]: basic.md#basic.scope.local
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
 [basic.start.init]: basic.md#basic.start.init
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
@@ -949,11 +1035,10 @@ int a[] =
 [class.inhctor]: special.md#class.inhctor
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
-[class.mfct.non-static]: class.md#class.mfct.non-static
 [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
@@ -961,19 +1046,21 @@ int a[] =
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
@@ -1011,15 +1098,18 @@ int a[] =
 [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.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]: expr.md#expr.prim
 [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
@@ -1030,19 +1120,19 @@ int a[] =
 [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
 [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.ics.rank]: over.md#over.ics.rank
 [over.match]: over.md#over.match
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
@@ -1058,11 +1148,10 @@ int a[] =
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
-[temp.arg]: temp.md#temp.arg
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
@@ -1077,39 +1166,35 @@ int a[] =
 [^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]: The resulting converted value will include an lvalue-to-rvalue
-    conversion ([[conv.lval]]) if the corresponding copy-initialization
-    requires one.
-[^4]: 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.
-[^5]: 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.
-[^6]: Although entities in an unnamed namespace might have external
     linkage, they are effectively qualified by a name unique to their
     translation unit and therefore can never be seen from any other
     translation unit.
-[^7]: this implies that the name of the class or function is
     unqualified.
-[^8]: 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.
-[^9]: A declaration with several declarators is usually equivalent to
     the corresponding sequence of declarations each with a single
     declarator. That is
     `T  D1, D2, ... Dn;`
@@ -1139,42 +1224,40 @@ int a[] =
     `auto i = 1, j = 2.0; \textrm{// error: deduced types for \tcode{i} and \tcode{j} do not match}`
     as opposed to
     `auto i = 1;    \textrm{// OK: \tcode{i} deduced to have type \tcode{int}}`
     `auto j = 2.0;  \textrm{// OK: \tcode{j} deduced to have type \tcode{double}}`
-[^10]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
-[^11]: This excludes parameters of type “ `T2`” where `T2` is “pointer
     to array of unknown bound of `T`” and where means any sequence of
     “pointer to” and “array of” derived declarator types. This exclusion
     applies to the parameters of the function, and if a parameter is a
     pointer to function or pointer to member function then to its
     parameters also, etc.
-[^12]: 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*).
-[^13]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
-[^14]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
     [[global.names]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
-[^15]: As specified in  [[conv.ptr]], converting an integral constant
- expression whose value is `0` to a pointer type results in a null
- pointer value.
-[^16]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
-[^17]: Braces cannot be elided in other uses of list-initialization.
-[^18]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

 Default arguments are more restricted; see  [[dcl.fct.default]].
 The order of initialization of variables with static storage duration is
 described in  [[basic.start]] and  [[stmt.dcl]].
+A declaration of a block-scope variable with external or internal
+linkage that has an *initializer* is ill-formed.
 To *zero-initialize* an object or reference of type `T` means:
+- if `T` is a scalar type ([[basic.types]]), the object is initialized
+ to the value obtained by converting the integer literal `0` (zero) to
+  `T`;[^14]
 - if `T` is a (possibly cv-qualified) non-union class type, each
   non-static data member and each base-class subobject is
   zero-initialized and padding is initialized to zero bits;
 - if `T` is a (possibly cv-qualified) union type, the object’s first
   non-static named data member is zero-initialized and padding is
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]]),
+  the default constructor ([[class.ctor]]) for `T` is called (and the
+ initialization is ill-formed if `T` has no default constructor or
+  overload resolution ([[over.match]]) results in an ambiguity or in a
+  function that is deleted or inaccessible from the context of the
+  initialization);
 - if `T` is an array type, each element is default-initialized;
 - otherwise, no initialization is performed.
 If a program calls for the default initialization of an object of a
 const-qualified type `T`, `T` shall be a class type with a user-provided
 default constructor.
 To *value-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]])
+  with either no default constructor ([[class.ctor]]) or a default
+  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.
 An object that is value-initialized is deemed to be constructed and thus
 subject to provisions of this International Standard applying to
 a function taking no argument and returning an `X`. The form `()` is
 permitted in certain other initialization contexts ([[expr.new]],
 [[expr.type.conv]], [[class.base.init]]).
 If no initializer is specified for an object, the object is
+default-initialized. When storage for an object with automatic or
+dynamic storage duration is obtained, the object has an *indeterminate
+value*, and if no initialization is performed for the object, that
+object retains an indeterminate value until that value is replaced (
+[[expr.ass]]). Objects with static or thread storage duration are
+zero-initialized, see  [[basic.start.init]]. If an indeterminate value
+is produced by an evaluation, the behavior is undefined except in the
+following cases:
+- If an indeterminate value of unsigned narrow character type (
+  [[basic.fundamental]]) is produced by the evaluation of:
+  - the second or third operand of a conditional expression (
+    [[expr.cond]]),
+  - the right operand of a comma expression ([[expr.comma]]),
+  - the operand of a cast or conversion to an unsigned narrow character
+    type ([[conv.integral]], [[expr.type.conv]], [[expr.static.cast]],
+    [[expr.cast]]), or
+  - a discarded-value expression (Clause  [[expr]]),
+  then the result of the operation is an indeterminate value.
+- If an indeterminate value of unsigned narrow character type is
+  produced by the evaluation of the right operand of a simple assignment
+  operator ([[expr.ass]]) whose first operand is an lvalue of unsigned
+  narrow character type, an indeterminate value replaces the value of
+  the object referred to by the left operand.
+- If an indeterminate value of unsigned narrow character type is
+  produced by the evaluation of the initialization expression when
+  initializing an object of unsigned narrow character type, that object
+  is initialized to an indeterminate value.
+``` cpp
+int f(bool b) {
+    unsigned char c;
+    unsigned char d = c; // OK, d has an indeterminate value
+    int e = d;           // undefined behavior
+    return b ? d : 0;    // undefined behavior if b is true
+  }
+```
 An initializer for a static member is in the scope of the member’s
 class.
 ``` cpp
 [[temp.variadic]]).
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
 An *aggregate* is an array or a class (Clause  [[class]]) with no
+user-provided constructors ([[class.ctor]]), no private or protected
+non-static data members (Clause  [[class.access]]), no base classes
+(Clause  [[class.derived]]), and no virtual functions (
+[[class.virtual]]).
 When an aggregate is initialized by an initializer list, as specified
 in  [[dcl.init.list]], the elements of the initializer list are taken as
 initializers for the members of the aggregate, in increasing subscript
 or member order. Each member is copy-initialized from the corresponding
 ```
 declares and initializes `x` as a one-dimensional array that has three
 elements since no size was specified and there are three initializers.
 An empty initializer list `{}` shall not be used as the
+*initializer-clause * for an array of unknown bound.[^15]
 Static data members and anonymous bit-fields are not considered members
 of the class for purposes of aggregate initialization.
 ``` cpp
 is ill-formed.
 If there are fewer *initializer-clause*s in the list than there are
 members in the aggregate, then each member not explicitly initialized
+shall be initialized from its *brace-or-equal-initializer* or, if there
+is no *brace-or-equal-initializer*, from an empty initializer list (
 [[dcl.init.list]]).
 ``` cpp
+struct S { int a; const char* b; int c; int d = b[a]; };
 S ss = { 1, "asdf" };
 ```
+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
 If an aggregate class `C` contains a subaggregate member `m` that has no
 members for purposes of aggregate initialization, the
 *initializer-clause* for `m` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
+Braces can be elided in an *initializer-list* as follows. If the
 *initializer-list* begins with a left brace, then the succeeding
 comma-separated list of *initializer-clause*s initializes the members of
 a subaggregate; it is erroneous for there to be more
 *initializer-clause*s than members. If, however, the *initializer-list*
 for a subaggregate does not begin with a left brace, then only enough
 union member can be omitted if the union is a member of another
 aggregate.
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
+An array of narrow character type ([[basic.fundamental]]), `char16_t`
+array, `char32_t` array, or `wchar_t` array can be initialized by a
+narrow string literal, `char16_t` string literal, `char32_t` string
+literal, or wide string literal, respectively, or by an
+appropriately-typed string literal enclosed in braces ([[lex.string]]).
+Successive characters of the value of the string literal initialize the
+elements of the array.
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 ```
 ```
 Given types “ `T1`” and “ `T2`,” “ `T1`” is to “ `T2`” if `T1` is the
 same type as `T2`, or `T1` is a base class of `T2`. “ `T1`” is with “
 `T2`” if `T1` is reference-related to `T2` and *cv1* is the same
+cv-qualification as, or greater cv-qualification than, *cv2*. In all
+cases where the reference-related or reference-compatible relationship
+of two types is used to establish the validity of a reference binding,
+and `T1` is a base class of `T2`, a program that necessitates such a
+binding is ill-formed if `T1` is an inaccessible (Clause
+[[class.access]]) or ambiguous ([[class.member.lookup]]) base class of
+`T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
   - is an lvalue (but is not a bit-field), and “ `T1`” is
     reference-compatible with “ `T2`,” or
   - has a class type (i.e., `T2` is a class type), where `T1` is not
+    reference-related to `T2`, and can be converted to an lvalue of type
+    “ `T3`,” where “ `T1`” is reference-compatible with “ `T3`”[^16]
+    (this conversion is selected by enumerating the applicable
+    conversion functions ([[over.match.ref]]) and choosing the best one
+    through overload resolution ([[over.match]])),
   then the reference is bound to the initializer expression lvalue in
   the first case and to the lvalue result of the conversion in the
   second case (or, in either case, to the appropriate base class
   subobject of the object). The usual lvalue-to-rvalue ([[conv.lval]]),
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   - If the initializer expression
+    - is an xvalue (but not a bit-field), class prvalue, array prvalue
+ or function lvalue and “*cv1* `T1`” is reference-compatible with
+      “*cv2* `T2`”, or
     - has a class type (i.e., `T2` is a class type), where `T1` is not
+      reference-related to `T2`, and can be converted to an xvalue,
+      class prvalue, or function lvalue of type “*cv3* `T3`”, where
+      “*cv1* `T1`” is reference-compatible with “*cv3* `T3`” (see
+      [[over.match.ref]]),
     then the reference is bound to the value of the initializer
     expression in the first case and to the result of the conversion in
     the second case (or, in either case, to an appropriate base class
     subobject). In the second case, if the reference is an rvalue
     int&& rri = static_cast<int&&>(i2); // bound directly to i2
     B&& rrb = x;                        // bound directly to the result of operator B
     int&& rri2 = X();                   // error: lvalue-to-rvalue conversion applied to the
                                         // result of operator int&
     ```
+  - Otherwise:
+ - If `T1` is a class type, user-defined conversions are considered
+      using the rules for copy-initialization of an object of type “
+ `T1`” by user-defined conversion ([[dcl.init]],
+      [[over.match.copy]]); the program is ill-formed if the
+      corresponding non-reference copy-initialization would be
+      ill-formed. The result of the call to the conversion function, as
+      described for the non-reference copy-initialization, is then used
+      to direct-initialize the reference. The program is ill-formed if
+      the direct-initialization does not result in a direct binding or
+      if it involves a user-defined conversion.
+    - If `T1` is a non-class type, a temporary of type “ `T1`” is
+      created and copy-initialized ([[dcl.init]]) from the initializer
+      expression. The reference is then bound to the temporary.
+    If `T1` is reference-related to `T2`:
+    - *cv1* shall be the same cv-qualification as, or greater
+      cv-qualification than, *cv2*; and
+    - if the reference is an rvalue reference, the initializer
+      expression shall not be an lvalue.
     ``` cpp
+    struct Banana { };
+    struct Enigma { operator const Banana(); };
+    void enigmatic() {
+      typedef const Banana ConstBanana;
+      Banana &&banana1 = ConstBanana(); // ill-formed
+      Banana &&banana2 = Enigma();      // ill-formed
+    }
     const double& rcd2 = 2;         // rcd2 refers to temporary with value 2.0
     double&& rrd = 2;               // rrd refers to temporary with value 2.0
     const volatile int cvi = 1;
     const int& r2 = cvi;            // error: type qualifiers dropped
     double d2 = 1.0;
 *copy-list-initialization*. List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
 - as the initializer in a new expression ([[expr.new]])
 - in a return statement ([[stmt.return]])
+- as a *for-range-initializer* ([[stmt.iter]])
 - as a function argument ([[expr.call]])
 - as a subscript ([[expr.sub]])
 - as an argument to a constructor invocation ([[dcl.init]],
   [[expr.type.conv]])
 - as an initializer for a non-static data member ([[class.mem]])
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
 arguments ([[dcl.fct.default]]). Initializer-list constructors are
 favored over other constructors in list-initialization (
+[[over.match.list]]). Passing an initializer list as the argument to the
+constructor template `template<class T> C(T)` of a class `C` does not
+create an initializer-list constructor, because an initializer list
+argument causes the corresponding parameter to be a non-deduced
+context ([[temp.deduct.call]]). The template `std::initializer_list` is
+not predefined; if the header `<initializer_list>` is not included prior
+to a use of `std::initializer_list` — even an implicit use in which the
 type is not named ([[dcl.spec.auto]]) — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
+- If `T` is an aggregate, aggregate initialization is performed (
+ [[dcl.init.aggr]]).
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
+- Otherwise, if the initializer list has no elements and `T` is a class
+ type with a default constructor, the object is value-initialized.
+- Otherwise, if `T` is a specialization of `std::initializer_list<E>`, a
+  prvalue `initializer_list` object is constructed as described below
+  and used to initialize the object according to the rules for
   initialization of an object from a class of the same type (
   [[dcl.init]]).
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
   through overload resolution ([[over.match]],  [[over.match.list]]).
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
+- Otherwise, if the initializer list has a single element of type `E`
+  and either `T` is not a reference type or its referenced type is
+  reference-related to `E`, the object or reference is initialized from
+  that element; if a narrowing conversion (see below) is required to
+  convert the element to `T`, the program is ill-formed.
+  ``` cpp
+  int x1 {2};                         // OK
+  int x2 {2.0};                       // error: narrowing
+  ```
 - Otherwise, if `T` is a reference type, a prvalue temporary of the type
+  referenced by `T` is copy-list-initialized or direct-list-initialized,
+ depending on the kind of initialization for the reference, and the
+ reference is bound to that temporary. As usual, the binding will fail
+ and the program is ill-formed if the reference type is an lvalue
+  reference to a non-const type.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
 example, it applies when the elements of the *initializer-list* are
 interpreted as arguments of a constructor call, even though ordinarily
 there are no sequencing constraints on the arguments of a call.
 An object of type `std::initializer_list<E>` is constructed from an
+initializer list as if the implementation allocated a temporary array of
+N elements of type `const E`, where N is the number of elements in the
 initializer list. Each element of that array is copy-initialized with
 the corresponding element of the initializer list, and the
 `std::initializer_list<E>` object is constructed to refer to that array.
+A constructor or conversion function selected for the copy shall be
+accessible (Clause  [[class.access]]) in the context of the initializer
+list. If a narrowing conversion is required to initialize any of the
+elements, the program is ill-formed.
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
 The initialization will be implemented in a way roughly equivalent to
 this:
 ``` cpp
+const double __a[3] = {double{1}, double{2}, double{3}};
 X x(std::initializer_list<double>(__a, __a+3));
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
+The array has the same lifetime as any other temporary object (
+[[class.temporary]]), except that initializing an `initializer_list`
+object from the array extends the lifetime of the array exactly like
+binding a reference to a temporary.
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
   std::vector<cmplx> v2{ 1, 2, 3 };
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
+struct A {
+  std::initializer_list<int> i4;
+  A() : i4{ 1, 2, 3 } {}  // creates an A with a dangling reference
+};
 ```
+For `v1` and `v2`, the `initializer_list` object is a parameter in a
+function call, so the array created for `{ 1, 2, 3 }` has
+full-expression lifetime. For `i3`, the `initializer_list` object is a
+variable, so the array persists for the lifetime of the variable. For
+`i4`, the `initializer_list` object is initialized in a constructor’s
+*ctor-initializer*, so the array persists only until the constructor
+exits, and so any use of the elements of `i4` after the constructor
+exits produces undefined behavior. The implementation is free to
+allocate the array in read-only memory if an explicit array with the
+same initializer could be so allocated.
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from `long double` to `double` or `float`, or from `double` to
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
+  where the source is a constant expression whose value after integral
+ promotions will fit into the target type.
 As indicated above, such conversions are not allowed at the top level in
 list-initializations.
 ``` cpp
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
+[basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.namespace]: basic.md#basic.scope.namespace
+[basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
 [basic.start.init]: basic.md#basic.start.init
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
 [class.inhctor]: special.md#class.inhctor
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
+[conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
+[dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [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]: expr.md#expr.prim.lambda
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [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.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
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
 [^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]: Although entities in an unnamed namespace might have external
     linkage, they are effectively qualified by a name unique to their
     translation unit and therefore can never be seen from any other
     translation unit.
+[^6]: this implies that the name of the class or function is
     unqualified.
+[^7]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
+[^8]: A declaration with several declarators is usually equivalent to
     the corresponding sequence of declarations each with a single
     declarator. That is
     `T  D1, D2, ... Dn;`
     `auto i = 1, j = 2.0; \textrm{// error: deduced types for \tcode{i} and \tcode{j} do not match}`
     as opposed to
     `auto i = 1;    \textrm{// OK: \tcode{i} deduced to have type \tcode{int}}`
     `auto j = 2.0;  \textrm{// OK: \tcode{j} deduced to have type \tcode{double}}`
+[^9]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
+[^10]: This excludes parameters of type “ `T2`” where `T2` is “pointer
     to array of unknown bound of `T`” and where means any sequence of
     “pointer to” and “array of” derived declarator types. This exclusion
     applies to the parameters of the function, and if a parameter is a
     pointer to function or pointer to member function then to its
     parameters also, etc.
+[^11]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
+[^12]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
+[^13]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
     [[global.names]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
+[^14]: As specified in  [[conv.ptr]], converting an integer literal
+    whose value is `0` to a pointer type results in a null pointer
+    value.
+[^15]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
+[^16]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

Diff to HTML by rtfpessoa