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

Files changed (1) hide show

tmp/tmpgckt6zrt/{from.md → to.md} +1249 -628

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

@@ -25,11 +25,62 @@ modify the type of the specifiers with operators such as `*` (pointer
 to) and `()` (function returning). Initial values can also be specified
 in a declarator; initializers are discussed in  [[dcl.init]] and
 [[class.init]].
 Each *init-declarator* in a declaration is analyzed separately as if it
-was in a declaration by itself.[^8]
 Declarators have the syntax
 ``` bnf
 declarator:
@@ -52,16 +103,16 @@ noptr-declarator:
 ```
 ``` bnf
 parameters-and-qualifiers:
     '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 ``` bnf
 trailing-return-type:
-    '->' trailing-type-specifier-seq abstract-declaratorₒₚₜ
 ```
 ``` bnf
 ptr-operator:
     '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ
@@ -90,21 +141,10 @@ ref-qualifier:
 ``` bnf
 declarator-id:
     '...'ₒₚₜ id-expression
 ```
-The optional *attribute-specifier-seq* in a *trailing-return-type*
-appertains to the indicated return type. The *type-id* in a
-*trailing-return-type* includes the longest possible sequence of
-*abstract-declarator*s. This resolves the ambiguous binding of array and
-function declarators.
-``` cpp
-auto f()->int(*)[4];  // function returning a pointer to array[4] of int
-                      // not function returning array[4] of pointer to int
-```
 ## Type names <a id="dcl.name">[[dcl.name]]</a>
 To specify type conversions explicitly, and as an argument of `sizeof`,
 `alignof`, `new`, or `typeid`, the name of a type shall be specified.
 This can be done with a *type-id*, which is syntactically a declaration
@@ -114,10 +154,15 @@ entity.
 ``` bnf
 type-id:
     type-specifier-seq abstract-declaratorₒₚₜ
 ```
 ``` bnf
 abstract-declarator:
     ptr-abstract-declarator
     noptr-abstract-declaratorₒₚₜ parameters-and-qualifiers trailing-return-type
     abstract-pack-declarator
@@ -152,25 +197,29 @@ noptr-abstract-pack-declarator:
 It is possible to identify uniquely the location in the
 *abstract-declarator* where the identifier would appear if the
 construction were a declarator in a declaration. The named type is then
 the same as the type of the hypothetical identifier.
 ``` cpp
 int                 // int i
 int *               // int *pi
 int *[3]            // int *p[3]
 int (*)[3]          // int (*p3i)[3]
 int *()             // int *f()
 int (*)(double)     // int (*pf)(double)
 ```
-name respectively the types “`int`,” “pointer to `int`,” “array of 3
-pointers to `int`,” “pointer to array of 3 `int`,” “function of (no
-parameters) returning pointer to `int`,” and “pointer to a function of
-(`double`) returning `int`.”
-A type can also be named (often more easily) by using a *typedef* (
 [[dcl.typedef]]).
 ## Ambiguity resolution <a id="dcl.ambig.res">[[dcl.ambig.res]]</a>
 The ambiguity arising from the similarity between a function-style cast
@@ -178,87 +227,76 @@ and a declaration mentioned in  [[stmt.ambig]] can also occur in the
 context of a declaration. In that context, the choice is between a
 function declaration with a redundant set of parentheses around a
 parameter name and an object declaration with a function-style cast as
 the initializer. Just as for the ambiguities mentioned in
 [[stmt.ambig]], the resolution is to consider any construct that could
-possibly be a declaration a declaration. A declaration can be explicitly
-disambiguated by a nonfunction-style cast, by an `=` to indicate
-initialization or by removing the redundant parentheses around the
-parameter name.
 ``` cpp
 struct S {
   S(int);
 };
 void foo(double a) {
   S w(int(a));                  // function declaration
   S x(int());                   // function declaration
   S y((int)a);                  // object declaration
   S z = int(a);                 // object declaration
 }
 ```
-The ambiguity arising from the similarity between a function-style cast
-and a *type-id* can occur in different contexts. The ambiguity appears
-as a choice between a function-style cast expression and a declaration
-of a type. The resolution is that any construct that could possibly be a
-*type-id* in its syntactic context shall be considered a *type-id*.
-``` cpp
-#include <cstddef>
-char* p;
-void* operator new(std::size_t, int);
-void foo()  {
-  const int x = 63;
-  new (int(*p)) int;            // new-placement expression
-  new (int(*[x]));              // new type-id
-}
-```
-For another example,
 ``` cpp
-template <class T>
-struct S {
-  T* p;
-};
-S<int()> x;                     // type-id
-S<int(1)> y;                    // expression (ill-formed)
-```
-For another example,
-``` cpp
-void foo() {
-  sizeof(int(1));               // expression
   sizeof(int());                // type-id (ill-formed)
 }
 ```
-For another example,
-``` cpp
-void foo() {
-  (int(1));                     // expression
-  (int())1;                     // type-id (ill-formed)
-}
-```
-Another ambiguity arises in a *parameter-declaration-clause* of a
-function declaration, or in a *type-id* that is the operand of a
-`sizeof` or `typeid` operator, when a *type-name* is nested in
-parentheses. In this case, the choice is between the declaration of a
-parameter of type pointer to function and the declaration of a parameter
-with redundant parentheses around the *declarator-id*. The resolution is
-to consider the *type-name* as a *simple-type-specifier* rather than a
-*declarator-id*.
 ``` cpp
 class C { };
 void f(int(C)) { }              // void f(int(*fp)(C c)) { }
-                                // not: void f(int C);
 int g(C);
 void foo() {
   f(1);                         // error: cannot convert 1 to function pointer
@@ -272,72 +310,82 @@ For another example,
 class C { };
 void h(int *(C[10]));           // void h(int *(*_fp)(C _parm[10]));
                                 // not: void h(int *C[10]);
 ```
 ## Meaning of declarators <a id="dcl.meaning">[[dcl.meaning]]</a>
-A list of declarators appears after an optional (Clause  [[dcl.dcl]])
-*decl-specifier-seq* ([[dcl.spec]]). Each declarator contains exactly
-one *declarator-id*; it names the identifier that is declared. An
-*unqualified-id* occurring in a *declarator-id* shall be a simple
-*identifier* except for the declaration of some special functions (
-[[class.ctor]], [[class.conv]], [[class.dtor]], [[over.oper]]) and for
-the declaration of template specializations or partial specializations (
-[[temp.spec]]). When the *declarator-id* is qualified, the declaration
-shall refer to a previously declared member of the class or namespace to
-which the qualifier refers (or, in the case of a namespace, of an
-element of the inline namespace set of that namespace (
-[[namespace.def]])) or to a specialization thereof; the member shall not
-merely have been introduced by a *using-declaration* in the scope of the
-class or namespace nominated by the *nested-name-specifier* of the
-*declarator-id*. The *nested-name-specifier* of a qualified
-*declarator-id* shall not begin with a *decltype-specifier*. If the
-qualifier is the global `::` scope resolution operator, the
-*declarator-id* refers to a name declared in the global namespace scope.
 The optional *attribute-specifier-seq* following a *declarator-id*
 appertains to the entity that is declared.
-A `static`, `thread_local`, `extern`, `register`, `mutable`, `friend`,
-`inline`, `virtual`, or `typedef` specifier applies directly to each
-*declarator-id* in an *init-declarator-list*; the type specified for
-each *declarator-id* depends on both the *decl-specifier-seq* and its
-*declarator*.
 Thus, a declaration of a particular identifier has the form
 ``` cpp
 T D
 ```
-where `T` is of the form *attribute-specifier-seqₒₚₜ*
 *decl-specifier-seq* and `D` is a declarator. Following is a recursive
 procedure for determining the type specified for the contained
 *declarator-id* by such a declaration.
 First, the *decl-specifier-seq* determines a type. In a declaration
 ``` cpp
 T D
 ```
-the *decl-specifier-seq* `T` determines the type `T`. in the declaration
 ``` cpp
 int unsigned i;
 ```
 the type specifiers `int` `unsigned` determine the type “`unsigned int`”
 ([[dcl.type.simple]]).
-In a declaration *attribute-specifier-seqₒₚₜ* `T` `D` where `D` is an
 unadorned identifier the type of this identifier is “`T`”.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
-( D1 )
 ```
 the type of the contained *declarator-id* is the same as that of the
 contained *declarator-id* in the declaration
@@ -354,18 +402,21 @@ In a declaration `T` `D` where `D` has the form
 ``` bnf
 '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
-and the type of the identifier in the declaration `T` `D1` is “ `T`,”
-then the type of the identifier of `D` is “ pointer to `T`.” The
-*cv-qualifier*s apply to the pointer and not to the object pointed to.
-Similarly, the optional *attribute-specifier-seq* (
 [[dcl.attr.grammar]]) appertains to the pointer and not to the object
 pointed to.
-the declarations
 ``` cpp
 const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
 int i, *p, *const cp = &i;
 ```
@@ -402,56 +453,68 @@ ppc = &p;           // error
 Each is unacceptable because it would either change the value of an
 object declared `const` or allow it to be changed through a
 cv-unqualified pointer later, for example:
 ``` cpp
-*ppc = &ci;         // OK, but would make p point to ci ...
-                    // ... because of previous error
 *p = 5;             // clobber ci
 ```
 See also  [[expr.ass]] and  [[dcl.init]].
-Forming a pointer to reference type is ill-formed; see  [[dcl.ref]].
-Forming a pointer to function type is ill-formed if the function type
-has *cv-qualifier*s or a *ref-qualifier*; see  [[dcl.fct]]. Since the
-address of a bit-field ([[class.bit]]) cannot be taken, a pointer can
-never point to a bit-field.
 ### References <a id="dcl.ref">[[dcl.ref]]</a>
 In a declaration `T` `D` where `D` has either of the forms
 ``` bnf
 '&' attribute-specifier-seqₒₚₜ 'D1'
 '&&' attribute-specifier-seqₒₚₜ 'D1'
 ```
-and the type of the identifier in the declaration `T` `D1` is “ `T`,”
-then the type of the identifier of `D` is “ reference to `T`.” The
-optional *attribute-specifier-seq* appertains to the reference type.
-Cv-qualified references are ill-formed except when the cv-qualifiers are
-introduced through the use of a *typedef-name* ([[dcl.typedef]],
-[[temp.param]]) or *decltype-specifier* ([[dcl.type.simple]]), in which
-case the cv-qualifiers are ignored.
 ``` cpp
 typedef int& A;
 const A aref = 3;   // ill-formed; lvalue reference to non-const initialized with rvalue
 ```
 The type of `aref` is “lvalue reference to `int`”, not “lvalue reference
-to `const int`”. A reference can be thought of as a name of an object. A
-declarator that specifies the type “reference to *cv* `void`” is
 ill-formed.
 A reference type that is declared using `&` is called an *lvalue
 reference*, and a reference type that is declared using `&&` is called
 an *rvalue reference*. Lvalue references and rvalue references are
 distinct types. Except where explicitly noted, they are semantically
 equivalent and commonly referred to as references.
 ``` cpp
 void f(double& a) { a += 3.14; }
 // ...
 double d = 0;
 f(d);
@@ -492,33 +555,42 @@ void k() {
 ```
 declares `p` to be a reference to a pointer to `link` so `h(q)` will
 leave `q` with the value zero. See also  [[dcl.init.ref]].
 It is unspecified whether or not a reference requires storage (
 [[basic.stc]]).
 There shall be no references to references, no arrays of references, and
 no pointers to references. The declaration of a reference shall contain
 an *initializer* ([[dcl.init.ref]]) except when the declaration
 contains an explicit `extern` specifier ([[dcl.stc]]), is a class
 member ([[class.mem]]) declaration within a class definition, or is the
 declaration of a parameter or a return type ([[dcl.fct]]); see
 [[basic.def]]. A reference shall be initialized to refer to a valid
-object or function. in particular, a null reference cannot exist in a
 well-defined program, because the only way to create such a reference
 would be to bind it to the “object” obtained by indirection through a
 null pointer, which causes undefined behavior. As described in
-[[class.bit]], a reference cannot be bound directly to a bit-field.
 If a *typedef-name* ([[dcl.typedef]], [[temp.param]]) or a
 *decltype-specifier* ([[dcl.type.simple]]) denotes a type `TR` that is
 a reference to a type `T`, an attempt to create the type “lvalue
 reference to cv `TR`” creates the type “lvalue reference to `T`”, while
 an attempt to create the type “rvalue reference to cv `TR`” creates the
 type `TR`.
 ``` cpp
 int i;
 typedef int& LRI;
 typedef int&& RRI;
@@ -531,26 +603,33 @@ RRI&& r5 = 5;                   // r5 has the type int&&
 decltype(r2)& r6 = i;           // r6 has the type int&
 decltype(r2)&& r7 = i;          // r7 has the type int&
 ```
-Forming a reference to function type is ill-formed if the function type
-has *cv-qualifier*s or a *ref-qualifier*; see  [[dcl.fct]].
 ### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
-nested-name-specifier '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ D1
 ```
 and the *nested-name-specifier* denotes a class, and the type of the
-identifier in the declaration `T` `D1` is “ `T`”, then the type of the
-identifier of `D` is “ pointer to member of class of type `T`”. The
-optional *attribute-specifier-seq* ([[dcl.attr.grammar]]) appertains to
-the pointer-to-member.
 ``` cpp
 struct X {
   void f(int);
   int a;
@@ -572,24 +651,24 @@ declaration of `pmc` is well-formed even though `Y` is an incomplete
 type. `pmi` and `pmf` can be used like this:
 ``` cpp
 X obj;
 // ...
-obj.*pmi = 7;       // assign 7 to an integer
- // member of obj
-(obj.*pmf)(7);      // call a function member of obj
-                    // with the argument 7
 ```
 A pointer to member shall not point to a static member of a class (
-[[class.static]]), a member with reference type, or “*cv* `void`.”
-See also  [[expr.unary]] and  [[expr.mptr.oper]]. The type “pointer to
-member” is distinct from the type “pointer”, that is, a pointer to
-member is declared only by the pointer to member declarator syntax, and
-never by the pointer declarator syntax. There is no
-“reference-to-member” type in C++.
 ### Arrays <a id="dcl.array">[[dcl.array]]</a>
 In a declaration `T` `D` where `D` has the form
@@ -598,56 +677,65 @@ In a declaration `T` `D` where `D` has the form
 ```
 and the type of the identifier in the declaration `T` `D1` is
 “*derived-declarator-type-list* `T`”, then the type of the identifier of
 `D` is an array type; if the type of the identifier of `D` contains the
-`auto` , the program is ill-formed. `T` is called the array *element
-type*; this type shall not be a reference type, the (possibly
-cv-qualified) type `void`, a function type or an abstract class type. If
-the *constant-expression* ([[expr.const]]) is present, it shall be a
 converted constant expression of type `std::size_t` and its value shall
 be greater than zero. The constant expression specifies the *bound* of
 (number of elements in) the array. If the value of the constant
 expression is `N`, the array has `N` elements numbered `0` to `N-1`, and
-the type of the identifier of `D` is “ array of `N` `T`”. An object of
-array type contains a contiguously allocated non-empty set of `N`
-subobjects of type `T`. Except as noted below, if the constant
-expression is omitted, the type of the identifier of `D` is “ array of
-unknown bound of `T`”, an incomplete object type. The type “ array of
-`N` `T`” is a different type from the type “ array of unknown bound of
-`T`”, see  [[basic.types]]. Any type of the form “ array of `N` `T`” is
-adjusted to “array of `N` `T`”, and similarly for “array of unknown
-bound of `T`”. The optional *attribute-specifier-seq* appertains to the
-array.
 ``` cpp
 typedef int A[5], AA[2][3];
 typedef const A CA;             // type is ``array of 5 const int''
 typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
 ```
-An “array of `N` `T`” has cv-qualified type; see
-[[basic.type.qualifier]].
 An array can be constructed from one of the fundamental types (except
 `void`), from a pointer, from a pointer to member, from a class, from an
 enumeration type, or from another array.
 When several “array of” specifications are adjacent, a multidimensional
-array is created; only the first of the constant expressions that
 specify the bounds of the arrays may be omitted. In addition to
 declarations in which an incomplete object type is allowed, an array
 bound may be omitted in some cases in the declaration of a function
 parameter ([[dcl.fct]]). An array bound may also be omitted when the
-declarator is followed by an *initializer* ([[dcl.init]]). In this case
-the bound is calculated from the number of initial elements (say, `N`)
-supplied ([[dcl.init.aggr]]), and the type of the identifier of `D` is
-“array of `N` `T`.” Furthermore, if there is a preceding declaration of
-the entity in the same scope in which the bound was specified, an
-omitted array bound is taken to be the same as in that earlier
-declaration, and similarly for the definition of a static data member of
-a class.
 ``` cpp
 float fa[17], *afp[17];
 ```
@@ -677,31 +765,38 @@ void f() {
   extern int x[];
   int i = sizeof(x);    // error: incomplete object type
 }
 ```
-conversions affecting expressions of array type are described in
-[[conv.array]]. Objects of array types cannot be modified, see
-[[basic.lval]].
-Except where it has been declared for a class ([[over.sub]]), the
-subscript operator `[]` is interpreted in such a way that `E1[E2]` is
-identical to `*((E1)+(E2))`. Because of the conversion rules that apply
-to `+`, if `E1` is an array and `E2` an integer, then `E1[E2]` refers to
-the `E2`-th member of `E1`. Therefore, despite its asymmetric
-appearance, subscripting is a commutative operation.
 A consistent rule is followed for multidimensional arrays. If `E` is an
 *n*-dimensional array of rank i × j × … × k, then `E` appearing in an
 expression that is subject to the array-to-pointer conversion (
 [[conv.array]]) is converted to a pointer to an (n-1)-dimensional array
 with rank j × … × k. If the `*` operator, either explicitly or
 implicitly as a result of subscripting, is applied to this pointer, the
 result is the pointed-to (n-1)-dimensional array, which itself is
 immediately converted into a pointer.
-consider
 ``` cpp
 int x[3][5];
 ```
@@ -714,50 +809,60 @@ multiplying `i` by the length of the object to which the pointer points,
 namely five integer objects. The results are added and indirection
 applied to yield an array (of five integers), which in turn is converted
 to a pointer to the first of the integers. If there is another subscript
 the same argument applies again; this time the result is an integer.
-It follows from all this that arrays in C++are stored row-wise (last
-subscript varies fastest) and that the first subscript in the
-declaration helps determine the amount of storage consumed by an array
-but plays no other part in subscript calculations.
 ### Functions <a id="dcl.fct">[[dcl.fct]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, the type of the
-*declarator-id* in `D` is “ function of ( ) returning `T`”. The optional
-*attribute-specifier-seq* appertains to the function type.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-type
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, `T` shall be the single
 *type-specifier* `auto`. The type of the *declarator-id* in `D` is
-“*derived-declarator-type-list* function of
-(*parameter-declaration-clause*) *cv-qualifier-seq*
-*ref-qualifier*returning *trailing-return-type*”. The optional
 *attribute-specifier-seq* appertains to the function type.
-A type of either form is a *function type*.[^9]
 ``` bnf
 parameter-declaration-clause:
-    parameter-declaration-listₒₚₜ ...ₒₚₜ
-    parameter-declaration-list ',' ...
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
@@ -774,23 +879,30 @@ parameter-declaration:
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
 The *parameter-declaration-clause* determines the arguments that can be
-specified, and their processing, when the function is called. the
-*parameter-declaration-clause* is used to convert the arguments
-specified on the function call; see  [[expr.call]]. If the
-*parameter-declaration-clause* is empty, the function takes no
 arguments. A parameter list consisting of a single unnamed parameter of
 non-dependent type `void` is equivalent to an empty parameter list.
 Except for this special case, a parameter shall not have type *cv*
 `void`. If the *parameter-declaration-clause* terminates with an
 ellipsis or a function parameter pack ([[temp.variadic]]), the number
 of arguments shall be equal to or greater than the number of parameters
 that do not have a default argument and are not function parameter
-packs. Where syntactically correct and where “” is not part of an
-*abstract-declarator*, “” is synonymous with “”. the declaration
 ``` cpp
 int printf(const char*, ...);
 ```
@@ -801,31 +913,35 @@ arguments.
 printf("hello world");
 printf("a=%d b=%d", a, b);
 ```
 However, the first argument must be of a type that can be converted to a
-`const` `char*` The standard header `<cstdarg>` contains a mechanism for
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
-[[support.runtime]]).
 A single name can be used for several different functions in a single
 scope; this is function overloading (Clause  [[over]]). All declarations
 for a function shall agree exactly in both the return type and the
 parameter-type-list. The type of a function is determined using the
 following rules. The type of each parameter (including function
 parameter packs) is determined from its own *decl-specifier-seq* and
 *declarator*. After determining the type of each parameter, any
-parameter of type “array of `T`” or “function returning `T`” is adjusted
-to be “pointer to `T`” or “pointer to function returning `T`,”
-respectively. After producing the list of parameter types, any top-level
-*cv-qualifier*s modifying a parameter type are deleted when forming the
-function type. The resulting list of transformed parameter types and the
-presence or absence of the ellipsis or a function parameter pack is the
-function’s *parameter-type-list*. This transformation does not affect
-the types of the parameters. For example,
-`int(*)(const int p, decltype(p)*)` and `int(*)(int, const int*)` are
-identical types.
 A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 (including a type named by *typedef-name* ([[dcl.typedef]],
 [[temp.param]])) shall appear only as:
@@ -836,82 +952,101 @@ A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 - the *type-id* in the default argument of a *type-parameter* (
   [[temp.param]]), or
 - the *type-id* of a *template-argument* for a *type-parameter* (
   [[temp.arg.type]]).
 ``` cpp
 typedef int FIC(int) const;
 FIC f;              // ill-formed: does not declare a member function
 struct S {
   FIC f;            // OK
 };
 FIC S::*pm = &S::f; // OK
 ```
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 same as adding cv-qualification on top of the function type. In the
-latter case, the cv-qualifiers are ignored. a function type that has a
-*cv-qualifier-seq* is not a cv-qualified type; there are no cv-qualified
-function types.
 ``` cpp
 typedef void F();
 struct S {
   const F f;        // OK: equivalent to: void f();
 };
 ```
-The return type, the parameter-type-list, the *ref-qualifier*, and the
-*cv-qualifier-seq*, but not the default arguments ([[dcl.fct.default]])
-or the exception specification ([[except.spec]]), are part of the
-function type. Function types are checked during the assignments and
 initializations of pointers to functions, references to functions, and
-pointers to member functions.
-the declaration
 ``` cpp
 int fseek(FILE*, long, int);
 ```
 declares a function taking three arguments of the specified types, and
 returning `int` ([[dcl.type]]).
-If the type of a parameter includes a type of the form “pointer to array
-of unknown bound of `T`” or “reference to array of unknown bound of
-`T`,” the program is ill-formed.[^10] Functions shall not have a return
-type of type array or function, although they may have a return type of
-type pointer or reference to such things. There shall be no arrays of
-functions, although there can be arrays of pointers to functions.
 Types shall not be defined in return or parameter types. The type of a
 parameter or the return type for a function definition shall not be an
-incomplete class type (possibly cv-qualified) unless the function is
-deleted ([[dcl.fct.def.delete]]) or the definition is nested within the
-*member-specification* for that class (including definitions in nested
-classes defined within the class).
 A typedef of function type may be used to declare a function but shall
 not be used to define a function ([[dcl.fct.def]]).
 ``` cpp
 typedef void F();
 F  fv;              // OK: equivalent to void fv();
 F  fv { }           // ill-formed
 void fv() { }       // OK: definition of fv
 ```
 An identifier can optionally be provided as a parameter name; if present
-in a function definition ([[dcl.fct.def]]), it names a parameter. In
-particular, parameter names are also optional in function definitions
-and names used for a parameter in different declarations and the
-definition of a function need not be the same. If a parameter name is
-present in a function declaration that is not a definition, it cannot be
-used outside of its function declarator because that is the extent of
-its potential scope ([[basic.scope.proto]]).
-the declaration
 ``` cpp
 int i,
     *pi,
     f(),
@@ -931,13 +1066,19 @@ The binding of `*fpi(int)` is `*(fpi(int))`, so the declaration
 suggests, and the same construction in an expression requires, the
 calling of a function `fpi`, and then using indirection through the
 (pointer) result to yield an integer. In the declarator
 `(*pif)(const char*, const char*)`, the extra parentheses are necessary
 to indicate that indirection through a pointer to a function yields a
-function, which is then called. Typedefs and *trailing-return-type*s are
-sometimes convenient when the return type of a function is complex. For
-example, the function `fpif` above could have been declared
 ``` cpp
 typedef int  IFUNC(int);
 IFUNC*  fpif(int);
 ```
@@ -959,21 +1100,30 @@ rather than
 ``` cpp
 template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);
 ```
 A *non-template function* is a function that is not a function template
-specialization. A function template is not a function.
 A *declarator-id* or *abstract-declarator* containing an ellipsis shall
 only be used in a *parameter-declaration*. Such a
 *parameter-declaration* is a parameter pack ([[temp.variadic]]). When
 it is part of a *parameter-declaration-clause*, the parameter pack is a
-function parameter pack ([[temp.variadic]]). Otherwise, the
-*parameter-declaration* is part of a *template-parameter-list* and the
-parameter pack is a template parameter pack; see  [[temp.param]]. A
-function parameter pack is a pack expansion ([[temp.variadic]]).
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
@@ -982,24 +1132,28 @@ float subtract(int, int);
 void g() {
   f(add, subtract);
 }
 ```
 There is a syntactic ambiguity when an ellipsis occurs at the end of a
 *parameter-declaration-clause* without a preceding comma. In this case,
 the ellipsis is parsed as part of the *abstract-declarator* if the type
 of the parameter either names a template parameter pack that has not
 been expanded or contains `auto`; otherwise, it is parsed as part of the
-*parameter-declaration-clause*.[^11]
 ### Default arguments <a id="dcl.fct.default">[[dcl.fct.default]]</a>
 If an *initializer-clause* is specified in a *parameter-declaration*
 this *initializer-clause* is used as a default argument. Default
 arguments will be used in calls where trailing arguments are missing.
-the declaration
 ``` cpp
 void point(int = 3, int = 4);
 ```
@@ -1011,17 +1165,20 @@ point(1,2);  point(1);  point();
 ```
 The last two calls are equivalent to `point(1,4)` and `point(3,4)`,
 respectively.
 A default argument shall be specified only in the
-*parameter-declaration-clause* of a function declaration or in a
-*template-parameter* ([[temp.param]]); in the latter case, the
-*initializer-clause* shall be an *assignment-expression*. A default
-argument shall not be specified for a parameter pack. If it is specified
-in a *parameter-declaration-clause*, it shall not occur within a
-*declarator* or *abstract-declarator* of a *parameter-declaration*.[^12]
 For non-template functions, default arguments can be added in later
 declarations of a function in the same scope. Declarations in different
 scopes have completely distinct sets of default arguments. That is,
 declarations in inner scopes do not acquire default arguments from
@@ -1030,33 +1187,35 @@ declaration, each parameter subsequent to a parameter with a default
 argument shall have a default argument supplied in this or a previous
 declaration or shall be a function parameter pack. A default argument
 shall not be redefined by a later declaration (not even to the same
 value).
 ``` cpp
 void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
                                 // a parameter with a default argument
 void f(int, int);
 void f(int, int = 7);
 void h() {
   f(3);                         // OK, calls f(3, 7)
-  void f(int = 1, int);         // error: does not use default
-                                // from surrounding scope
 }
 void m() {
   void f(int, int);             // has no defaults
   f(4);                         // error: wrong number of arguments
   void f(int, int = 5);         // OK
   f(4);                         // OK, calls f(4, 5);
-  void f(int, int = 5);         // error: cannot redefine, even to
-                                // same value
 }
 void n() {
   f(6);                         // OK, calls f(6, 7)
 }
 ```
 For a given inline function defined in different translation units, the
 accumulated sets of default arguments at the end of the translation
 units shall be the same; see  [[basic.def.odr]]. If a friend declaration
 specifies a default argument expression, that declaration shall be a
 definition and shall be the only declaration of the function or function
@@ -1067,12 +1226,15 @@ initializer in a declaration of a variable of the parameter type, using
 the copy-initialization semantics ([[dcl.init]]). The names in the
 default argument are bound, and the semantic constraints are checked, at
 the point where the default argument appears. Name lookup and checking
 of semantic constraints for default arguments in function templates and
 in member functions of class templates are performed as described in
-[[temp.inst]]. in the following code, `g` will be called with the value
-`f(2)`:
 ``` cpp
 int a = 1;
 int f(int);
 int g(int x = f(a));            // default argument: f(::a)
@@ -1084,13 +1246,16 @@ void h() {
   g();                          // g(f(::a))
   }
 }
 ```
-In member function declarations, names in default arguments are looked
-up as described in  [[basic.lookup.unqual]]. Access checking applies to
-names in default arguments as described in Clause  [[class.access]].
 Except for member functions of class templates, the default arguments in
 a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
@@ -1098,80 +1263,105 @@ ill-formed if a default constructor ([[class.ctor]]), copy or move
 constructor, or copy or move assignment operator ([[class.copy]]) is so
 declared. Default arguments for a member function of a class template
 shall be specified on the initial declaration of the member function
 within the class template.
 ``` cpp
 class C {
   void f(int i = 3);
   void g(int i, int j = 99);
 };
-void C::f(int i = 3) { // error: default argument already
-} // specified in class scope
-void C::g(int i = 88, int j) {  // in this translation unit,
-}                               // C::g can be called with no argument
 ```
-Local variables shall not be used in a default argument.
 ``` cpp
 void f() {
   int i;
   extern void g(int x = i);         // error
   // ...
 }
 ```
-The keyword `this` shall not be used in a default argument of a member
-function.
 ``` cpp
 class A {
   void f(A* p = this) { }           // error
 };
 ```
 A default argument is evaluated each time the function is called with no
-argument for the corresponding parameter. The order of evaluation of
-function arguments is unspecified. Consequently, parameters of a
-function shall not be used in a default argument, even if they are not
-evaluated. Parameters of a function declared before a default argument
-are in scope and can hide namespace and class member names.
 ``` cpp
 int a;
-int f(int a, int b = a);            // error: parameter a
-                                    // used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter I found
-int h(int a, int b = sizeof(a));    // error, parameter a used
-                                    // in default argument
 ```
-Similarly, a non-static member shall not be used in a default argument,
-even if it is not evaluated, unless it appears as the *id-expression* of
-a class member access expression ([[expr.ref]]) or unless it is used to
-form a pointer to member ([[expr.unary.op]]). the declaration of
-`X::mem1()` in the following example is ill-formed because no object is
-supplied for the non-static member `X::a` used as an initializer.
 ``` cpp
 int b;
 class X {
   int a;
-  int mem1(int i = a); // error: non-static member a
-                                // used as default argument
   int mem2(int i = b);              // OK;  use X::b
   static int b;
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
 is needed to access the static member `X::b`. Classes, objects, and
-members are described in Clause  [[class]]. A default argument is not
-part of the type of a function.
 ``` cpp
 int f(int = 0);
 void h() {
@@ -1181,10 +1371,12 @@ void h() {
 int (*p1)(int) = &f;
 int (*p2)() = &f;                   // error: type mismatch
 ```
 When a declaration of a function is introduced by way of a
 *using-declaration* ([[namespace.udecl]]), any default argument
 information associated with the declaration is made known as well. If
 the function is redeclared thereafter in the namespace with additional
 default arguments, the additional arguments are also known at any point
@@ -1194,10 +1386,12 @@ A virtual function call ([[class.virtual]]) uses the default arguments
 in the declaration of the virtual function determined by the static type
 of the pointer or reference denoting the object. An overriding function
 in a derived class does not acquire default arguments from the function
 it overrides.
 ``` cpp
 struct A {
   virtual void f(int a = 7);
 };
 struct B : public A {
@@ -1209,10 +1403,12 @@ void m() {
   pa->f();          // OK, calls pa->B::f(7)
   pb->f();          // error: wrong number of arguments for B::f()
 }
 ```
 ## Function definitions <a id="dcl.fct.def">[[dcl.fct.def]]</a>
 ### In general <a id="dcl.fct.def.general">[[dcl.fct.def.general]]</a>
 Function definitions have the form
@@ -1234,22 +1430,18 @@ Any informal reference to the body of a function should be interpreted
 as a reference to the non-terminal *function-body*. The optional
 *attribute-specifier-seq* in a *function-definition* appertains to the
 function. A *virt-specifier-seq* can be part of a *function-definition*
 only if it is a *member-declaration* ([[class.mem]]).
-The *declarator* in a *function-definition* shall have the form
-``` bnf
-'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-      ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
-```
-as described in  [[dcl.fct]]. A function shall be defined only in
-namespace or class scope.
-a simple example of a complete function definition is
 ``` cpp
 int max(int a, int b, int c) {
   int m = (a > b) ? a : b;
   return (m > c) ? m : c;
@@ -1257,26 +1449,30 @@ int max(int a, int b, int c) {
 ```
 Here `int` is the *decl-specifier-seq*; `max(int` `a,` `int` `b,` `int`
 `c)` is the *declarator*; `{ /* ... */ }` is the *function-body*.
 A *ctor-initializer* is used only in a constructor; see  [[class.ctor]]
 and  [[class.init]].
-A *cv-qualifier-seq* or a *ref-qualifier* (or both) can be part of a
-non-static member function declaration, non-static member function
-definition, or pointer to member function only ([[dcl.fct]]); see
-[[class.this]].
 Unused parameters need not be named. For example,
 ``` cpp
 void print(int a, int) {
   std::printf("a = %d\n",a);
 }
 ```
 In the *function-body*, a *function-local predefined variable* denotes a
 block-scope object of static storage duration that is implicitly defined
 (see  [[basic.scope.block]]).
 The function-local predefined variable `__func__` is defined as if a
@@ -1286,20 +1482,24 @@ definition of the form
 static const char __func__[] = "function-name";
 ```
 had been provided, where *function-name* is an *implementation-defined*
 string. It is unspecified whether such a variable has an address
-distinct from that of any other object in the program.[^13]
 ``` cpp
 struct S {
   S() : s(__func__) { }             // OK
   const char* s;
 };
 void f(const char* s = __func__);   // error: __func__ is undeclared
 ```
 ### Explicitly-defaulted functions <a id="dcl.fct.def.default">[[dcl.fct.def.default]]</a>
 A function definition of the form:
 ``` bnf
@@ -1315,52 +1515,58 @@ explicitly defaulted shall
   copy assignment operator, the parameter type may be “reference to
   non-const `T`”, where `T` is the name of the member function’s class)
   as if it had been implicitly declared, and
 - not have default arguments.
-An explicitly-defaulted function may be declared `constexpr` only if it
-would have been implicitly declared as `constexpr`. If a function is
-explicitly defaulted on its first declaration,
-- it is implicitly considered to be `constexpr` if the implicit
-  declaration would be, and,
-- it is implicitly considered to have the same *exception-specification*
-  as if it had been implicitly declared ([[except.spec]]).
-If a function that is explicitly defaulted has an explicit
-*exception-specification* that is not compatible ([[except.spec]]) with
-the *exception-specification* on the implicit declaration, then
 - if the function is explicitly defaulted on its first declaration, it
   is defined as deleted;
 - otherwise, the program is ill-formed.
 ``` cpp
 struct S {
   constexpr S() = default;              // ill-formed: implicit S() is not constexpr
   S(int a = 0) = default;               // ill-formed: default argument
   void operator=(const S&) = default;   // ill-formed: non-matching return type
-  ~S() throw(int) = default; // deleted: exception specification does not match
 private:
   int i;
   S(S&);                                // OK: private copy constructor
 };
 S::S(S&) = default;                     // OK: defines copy constructor
 ```
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
 provide implicit definitions for them ([[class.ctor]] [[class.dtor]],
 [[class.copy]]), which might mean defining them as deleted. A function
 is *user-provided* if it is user-declared and not explicitly defaulted
 or deleted on its first declaration. A user-provided
 explicitly-defaulted function (i.e., explicitly defaulted after its
 first declaration) is defined at the point where it is explicitly
 defaulted; if such a function is implicitly defined as deleted, the
-program is ill-formed. Declaring a function as defaulted after its first
 declaration can provide efficient execution and concise definition while
-enabling a stable binary interface to an evolving code base.
 ``` cpp
 struct trivial {
   trivial() = default;
   trivial(const trivial&) = default;
@@ -1374,10 +1580,12 @@ struct nontrivial1 {
   nontrivial1();
 };
 nontrivial1::nontrivial1() = default;   // not first declaration
 ```
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
 A function definition of the form:
 ``` bnf
@@ -1386,29 +1594,38 @@ attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-spe
 is called a *deleted definition*. A function with a deleted definition
 is also called a *deleted function*.
 A program that refers to a deleted function implicitly or explicitly,
-other than to declare it, is ill-formed. This includes calling the
-function implicitly or explicitly and forming a pointer or
-pointer-to-member to the function. It applies even for references in
-expressions that are not potentially-evaluated. If a function is
-overloaded, it is referenced only if the function is selected by
-overload resolution.
-One can enforce non-default initialization and non-integral
 initialization with
 ``` cpp
 struct onlydouble {
   onlydouble() = delete;                // OK, but redundant
   onlydouble(std::intmax_t) = delete;
   onlydouble(double);
 };
 ```
-One can prevent use of a class in certain `new` expressions by using
 deleted definitions of a user-declared `operator new` for that class.
 ``` cpp
 struct sometype {
   void* operator new(std::size_t) = delete;
@@ -1416,10 +1633,14 @@ struct sometype {
 };
 sometype* p = new sometype;     // error, deleted class operator new
 sometype* q = new sometype[3];  // error, deleted class operator new[]
 ```
 One can make a class uncopyable, i.e. move-only, by using deleted
 definitions of the copy constructor and copy assignment operator, and
 then providing defaulted definitions of the move constructor and move
 assignment operator.
@@ -1434,32 +1655,128 @@ struct moveonly {
 };
 moveonly* p;
 moveonly q(*p);                 // error, deleted copy constructor
 ```
-A deleted function is implicitly inline. The one-definition rule (
-[[basic.def.odr]]) applies to deleted definitions. A deleted definition
-of a function shall be the first declaration of the function or, for an
-explicit specialization of a function template, the first declaration of
-that specialization.
 ``` cpp
 struct sometype {
   sometype();
 };
 sometype::sometype() = delete;  // ill-formed; not first declaration
 ```
 ## 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 with argument
-expressions ([[expr.call]]) or the initialization of return values (
-[[stmt.return]]).
 ``` bnf
 initializer:
     brace-or-equal-initializer
     '(' expression-list ')'
@@ -1487,59 +1804,87 @@ initializer-list:
 braced-init-list:
     '{' initializer-list ','ₒₚₜ '}'
     '{' '}'
 ```
 Except for objects declared with the `constexpr` specifier, for which
 see  [[dcl.constexpr]], an *initializer* in the definition of a variable
 can consist of arbitrary expressions involving literals and previously
 declared variables and functions, regardless of the variable’s storage
 duration.
 ``` cpp
 int f(int);
 int a = 2;
 int b = f(a);
 int c(b);
 ```
-Default arguments are more restricted; see  [[dcl.fct.default]].
-The order of initialization of variables with static storage duration is
-described in  [[basic.start]] and  [[stmt.dcl]].
 A declaration of a block-scope variable with external or internal
 linkage that has an *initializer* is ill-formed.
 To *zero-initialize* an object or reference of type `T` means:
 - if `T` is a scalar type ([[basic.types]]), the object is initialized
   to the value obtained by converting the integer literal `0` (zero) to
-  `T`;[^14]
 - if `T` is a (possibly cv-qualified) non-union class type, each
-  non-static data member and each base-class subobject is
- zero-initialized and padding is initialized to zero bits;
 - if `T` is a (possibly cv-qualified) union type, the object’s first
   non-static named data member is zero-initialized and padding is
   initialized to zero bits;
 - if `T` is an array type, each element is zero-initialized;
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
-- if `T` is a (possibly cv-qualified) class type (Clause  [[class]]),
- the default constructor ([[class.ctor]]) for `T` is called (and the
- initialization is ill-formed if `T` has no default constructor or
- overload resolution ([[over.match]]) results in an ambiguity or in a
- function that is deleted or inaccessible from the context of the
- initialization);
-- if `T` is an array type, each element is default-initialized;
-- otherwise, no initialization is performed.
-If a program calls for the default initialization of an object of a
-const-qualified type `T`, `T` shall be a class type with a user-provided
-default constructor.
 To *value-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]])
   with either no default constructor ([[class.ctor]]) or a default
@@ -1551,26 +1896,22 @@ To *value-initialize* an object of type `T` means:
   and if `T` has a non-trivial default constructor, the object is
   default-initialized;
 - if `T` is an array type, then each element is value-initialized;
 - otherwise, the object is zero-initialized.
-An object that is value-initialized is deemed to be constructed and thus
-subject to provisions of this International Standard applying to
-“constructed” objects, objects “for which the constructor has
-completed,” etc., even if no constructor is invoked for the object’s
-initialization.
 A program that calls for default-initialization or value-initialization
 of an entity of reference type is ill-formed.
-Every object of static storage duration is zero-initialized at program
-startup before any other initialization takes place. In some cases,
-additional initialization is done later.
 An object whose initializer is an empty set of parentheses, i.e., `()`,
 shall be value-initialized.
 Since `()` is not permitted by the syntax for *initializer*,
 ``` cpp
 X a();
 ```
@@ -1578,53 +1919,71 @@ X a();
 is not the declaration of an object of class `X`, but the declaration of
 a function taking no argument and returning an `X`. The form `()` is
 permitted in certain other initialization contexts ([[expr.new]],
 [[expr.type.conv]], [[class.base.init]]).
 If no initializer is specified for an object, the object is
 default-initialized. When storage for an object with automatic or
 dynamic storage duration is obtained, the object has an *indeterminate
 value*, and if no initialization is performed for the object, that
 object retains an indeterminate value until that value is replaced (
-[[expr.ass]]). Objects with static or thread storage duration are
-zero-initialized, see  [[basic.start.init]]. If an indeterminate value
-is produced by an evaluation, the behavior is undefined except in the
-following cases:
 - If an indeterminate value of unsigned narrow character type (
-  [[basic.fundamental]]) is produced by the evaluation of:
   - the second or third operand of a conditional expression (
     [[expr.cond]]),
   - the right operand of a comma expression ([[expr.comma]]),
-  - the operand of a cast or conversion to an unsigned narrow character
- type ([[conv.integral]], [[expr.type.conv]], [[expr.static.cast]],
- [[expr.cast]]), or
   - a discarded-value expression (Clause  [[expr]]),
   then the result of the operation is an indeterminate value.
-- If an indeterminate value of unsigned narrow character type is
-  produced by the evaluation of the right operand of a simple assignment
-  operator ([[expr.ass]]) whose first operand is an lvalue of unsigned
-  narrow character type, an indeterminate value replaces the value of
-  the object referred to by the left operand.
 - If an indeterminate value of unsigned narrow character type is
   produced by the evaluation of the initialization expression when
   initializing an object of unsigned narrow character type, that object
   is initialized to an indeterminate value.
 ``` cpp
   int f(bool b) {
     unsigned char c;
     unsigned char d = c;        // OK, d has an indeterminate value
     int e = d;                  // undefined behavior
     return b ? d : 0;           // undefined behavior if b is true
   }
 ```
 An initializer for a static member is in the scope of the member’s
 class.
 ``` cpp
 int a;
 struct X {
   static int a;
@@ -1633,60 +1992,65 @@ struct X {
 int X::a = 1;
 int X::b = a;                   // X::b = X::a
 ```
-The form of initialization (using parentheses or `=`) is generally
-insignificant, but does matter when the initializer or the entity being
-initialized has a class type; see below. If the entity being initialized
-does not have class type, the *expression-list* in a parenthesized
-initializer shall be a single expression.
-The initialization that occurs in the form
-``` cpp
-T x = a;
-```
-as well as in argument passing, function return, throwing an exception (
 [[except.throw]]), handling an exception ([[except.handle]]), and
-aggregate member initialization ([[dcl.init.aggr]]) is called
-*copy-initialization*. Copy-initialization may invoke a move (
-[[class.copy]]).
 The initialization that occurs in the forms
 ``` cpp
 T x(a);
 T x{a};
 ```
-as well as in `new` expressions ([[expr.new]]), `static_cast`
-expressions ([[expr.static.cast]]), functional notation type
-conversions ([[expr.type.conv]]), and base and member initializers (
-[[class.base.init]]) is called *direct-initialization*.
 The semantics of initializers are as follows. The *destination type* is
 the type of the object or reference being initialized and the *source
 type* is the type of the initializer expression. If the initializer is
 not a single (possibly parenthesized) expression, the source type is not
 defined.
-- If the initializer is a (non-parenthesized) *braced-init-list*, the
-  object or reference is list-initialized ([[dcl.init.list]]).
 - If the destination type is a reference type, see  [[dcl.init.ref]].
 - If the destination type is an array of characters, an array of
   `char16_t`, an array of `char32_t`, or an array of `wchar_t`, and the
   initializer is a string literal, see  [[dcl.init.string]].
 - If the initializer is `()`, the object is value-initialized.
 - Otherwise, if the destination type is an array, the program is
   ill-formed.
 - If the destination type is a (possibly cv-qualified) class type:
-  - If the initialization is direct-initialization, or if it is
- copy-initialization where the cv-unqualified version of the source
- type is the same class as, or a derived class of, the class of the
-    destination, constructors are considered. The applicable
     constructors are enumerated ([[over.match.ctor]]), and the best one
     is chosen through overload resolution ([[over.match]]). The
     constructor so selected is called to initialize the object, with the
     initializer expression or *expression-list* as its argument(s). If
     no constructor applies, or the overload resolution is ambiguous, the
@@ -1697,20 +2061,15 @@ defined.
     to a derived class thereof are enumerated as described in
     [[over.match.copy]], and the best one is chosen through overload
     resolution ([[over.match]]). If the conversion cannot be done or is
     ambiguous, the initialization is ill-formed. The function selected
     is called with the initializer expression as its argument; if the
-    function is a constructor, the call initializes a temporary of the
-    cv-unqualified version of the destination type. The temporary is a
- prvalue. The result of the call (which is the temporary for the
- constructor case) is then used to direct-initialize, according to
-    the rules above, the object that is the destination of the
-    copy-initialization. In certain cases, an implementation is
-    permitted to eliminate the copying inherent in this
-    direct-initialization by constructing the intermediate result
-    directly into the object being initialized; see
-    [[class.temporary]], [[class.copy]].
 - Otherwise, if the source type is a (possibly cv-qualified) class type,
   conversion functions are considered. The applicable conversion
   functions are enumerated ([[over.match.conv]]), and the best one is
   chosen through overload resolution ([[over.match]]). The user-defined
   conversion so selected is called to convert the initializer expression
@@ -1719,40 +2078,84 @@ defined.
 - Otherwise, the initial value of the object being initialized is the
   (possibly converted) value of the initializer expression. Standard
   conversions (Clause  [[conv]]) will be used, if necessary, to convert
   the initializer expression to the cv-unqualified version of the
   destination type; no user-defined conversions are considered. If the
-  conversion cannot be done, the initialization is ill-formed. An
- expression of type “ `T`” can initialize an object of type “ `T`”
- independently of the cv-qualifiers and .
   ``` cpp
   int a;
   const int b = a;
   int c = b;
   ```
 An *initializer-clause* followed by an ellipsis is a pack expansion (
 [[temp.variadic]]).
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
-An *aggregate* is an array or a class (Clause  [[class]]) with no
-user-provided constructors ([[class.ctor]]), no private or protected
-non-static data members (Clause  [[class.access]]), no base classes
-(Clause  [[class.derived]]), and no virtual functions (
-[[class.virtual]]).
-When an aggregate is initialized by an initializer list, as specified
-in  [[dcl.init.list]], the elements of the initializer list are taken as
-initializers for the members of the aggregate, in increasing subscript
-or member order. Each member is copy-initialized from the corresponding
-*initializer-clause*. If the *initializer-clause* is an expression and a
-narrowing conversion ([[dcl.init.list]]) is required to convert the
-expression, the program is ill-formed. If an *initializer-clause* is
-itself an initializer list, the member is list-initialized, which will
-result in a recursive application of the rules in this section if the
-member is an aggregate.
 ``` cpp
 struct A {
   int x;
   struct B {
@@ -1762,29 +2165,79 @@ struct A {
 } a = { 1, { 2, 3 } };
 ```
 initializes `a.x` with 1, `a.b.i` with 2, `a.b.j` with 3.
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in  [[dcl.init]].
-An array of unknown size initialized with a brace-enclosed
 *initializer-list* containing `n` *initializer-clause*s, where `n` shall
-be greater than zero, is defined as having `n` elements (
 [[dcl.array]]).
 ``` cpp
 int x[] = { 1, 3, 5 };
 ```
 declares and initializes `x` as a one-dimensional array that has three
 elements since no size was specified and there are three initializers.
 An empty initializer list `{}` shall not be used as the
-*initializer-clause * for an array of unknown bound.[^15]
-Static data members and anonymous bit-fields are not considered members
-of the class for purposes of aggregate initialization.
 ``` cpp
 struct A {
   int i;
   static int s;
@@ -1794,27 +2247,47 @@ struct A {
 } a = { 1, 2, 3 };
 ```
 Here, the second initializer 2 initializes `a.j` and not the static data
 member `A::s`, and the third initializer 3 initializes `a.k` and not the
-anonymous bit-field before it.
 An *initializer-list* is ill-formed if the number of
-*initializer-clause*s exceeds the number of members or elements to
-initialize.
 ``` cpp
 char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
 ```
 is ill-formed.
 If there are fewer *initializer-clause*s in the list than there are
-members in the aggregate, then each member not explicitly initialized
-shall be initialized from its *brace-or-equal-initializer* or, if there
-is no *brace-or-equal-initializer*, from an empty initializer list (
-[[dcl.init.list]]).
 ``` cpp
 struct S { int a; const char* b; int c; int d = b[a]; };
 S ss = { 1, "asdf" };
 ```
@@ -1829,17 +2302,39 @@ X a[] = { 1, 2, 3, 4, 5, 6 };
 X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
 ```
 `a` and `b` have the same value
-If an aggregate class `C` contains a subaggregate member `m` that has no
-members for purposes of aggregate initialization, the
-*initializer-clause* for `m` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
-*initializer-clause*s for all members of `C` following `m` are also
 omitted.
 ``` cpp
 struct S { } s;
 struct A {
   S s1;
   int i1;
@@ -1853,17 +2348,18 @@ struct A {
   s,                // Required initialization
   0
 };                  // Initialization not required for A::s3 because A::i3 is also not initialized
 ```
-If an incomplete or empty *initializer-list* leaves a member of
-reference type uninitialized, the program is ill-formed.
 When initializing a multi-dimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
 varying the fastest ([[dcl.array]]).
 ``` cpp
 int x[2][2] = { 3, 1, 4, 2 };
 ```
 initializes `x[0][0]` to `3`, `x[0][1]` to `1`, `x[1][0]` to `4`, and
@@ -1876,20 +2372,24 @@ float y[4][3] = {
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
 Braces can be elided in an *initializer-list* as follows. If the
 *initializer-list* begins with a left brace, then the succeeding
-comma-separated list of *initializer-clause*s initializes the members of
-a subaggregate; it is erroneous for there to be more
-*initializer-clause*s than members. If, however, the *initializer-list*
 for a subaggregate does not begin with a left brace, then only enough
-*initializer-clause*s from the list are taken to initialize the members
 of the subaggregate; any remaining *initializer-clause*s are left to
-initialize the next member of the aggregate of which the current
-subaggregate is a member.
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
@@ -1915,19 +2415,24 @@ float y[4][3] = {
 The initializer for `y` begins with a left brace, but the one for `y[0]`
 does not, therefore three elements from the list are used. Likewise the
 next three are taken successively for `y[1]` and `y[2]`.
 All implicit type conversions (Clause  [[conv]]) are considered when
-initializing the aggregate member with an *assignment-expression*. If
-the *assignment-expression* can initialize a member, the member is
-initialized. Otherwise, if the member is itself a subaggregate, brace
 elision is assumed and the *assignment-expression* is considered for the
-initialization of the first member of the subaggregate. As specified
-above, brace elision cannot apply to subaggregates with no members for
-purposes of aggregate initialization; an *initializer-clause* for the
-entire subobject is required.
 ``` cpp
 struct A {
   int i;
   operator int();
@@ -1942,34 +2447,41 @@ B b = { 4, a, a };
 Braces are elided around the *initializer-clause* for `b.a1.i`. `b.a1.i`
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
-An aggregate array or an aggregate class may contain members of a class
-type with a user-provided constructor ([[class.ctor]]). Initialization
-of these aggregate objects is described in  [[class.expl.init]].
-Whether the initialization of aggregates with static storage duration is
-static or dynamic is specified in  [[basic.start.init]] and
-[[stmt.dcl]].
 When a union is initialized with a brace-enclosed initializer, the
 braces shall only contain an *initializer-clause* for the first
 non-static data member of the union.
 ``` cpp
 union u { int a; const char* b; };
 u a = { 1 };
 u b = a;
 u c = 1;                        // error
 u d = { 0, "asdf" };            // error
 u e = { "asdf" };               // error
 ```
-As described above, the braces around the *initializer-clause* for a
-union member can be omitted if the union is a member of another
-aggregate.
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 An array of narrow character type ([[basic.fundamental]]), `char16_t`
 array, `char32_t` array, or `wchar_t` array can be initialized by a
@@ -1977,38 +2489,47 @@ narrow string literal, `char16_t` string literal, `char32_t` string
 literal, or wide string literal, respectively, or by an
 appropriately-typed string literal enclosed in braces ([[lex.string]]).
 Successive characters of the value of the string literal initialize the
 elements of the array.
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 ```
 shows a character array whose members are initialized with a
 *string-literal*. Note that because `'\n'` is a single character and
 because a trailing `'\0'` is appended, `sizeof(msg)` is `25`.
 There shall not be more initializers than there are array elements.
 ``` cpp
 char cv[4] = "asdf";            // error
 ```
 is ill-formed since there is no space for the implied trailing `'\0'`.
 If there are fewer initializers than there are array elements, each
 element not explicitly initialized shall be zero-initialized (
 [[dcl.init]]).
 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
-A variable declared to be a `T&` or `T&&`, that is, “reference to type
-`T`” ([[dcl.ref]]), shall be initialized by an object, or function, of
-type `T` or by an object that can be converted into a `T`.
 ``` cpp
-int g(int);
 void f() {
   int i;
   int& r = i;                   // r refers to i
   r = 1;                        // the value of i becomes 1
   int* p = &r;                  // p points to i
@@ -2019,56 +2540,75 @@ void f() {
   int (&ra)[3] = a;             // ra refers to the array a
   ra[1] = i;                    // modifies a[1]
 }
 ```
 A reference cannot be changed to refer to another object after
-initialization. Note that initialization of a reference is treated very
-differently from assignment to it. Argument passing ([[expr.call]]) and
-function value return ([[stmt.return]]) are initializations.
 The initializer can be omitted for a reference only in a parameter
 declaration ([[dcl.fct]]), in the declaration of a function return
 type, in the declaration of a class member within its class definition (
 [[class.mem]]), and where the `extern` specifier is explicitly used.
 ``` cpp
 int& r1;                        // error: initializer missing
 extern int& r2;                 // OK
 ```
-Given types “ `T1`” and “ `T2`,” “ `T1`” is to “ `T2`” if `T1` is the
-same type as `T2`, or `T1` is a base class of `T2`. “ `T1`” is with “
-`T2`” if `T1` is reference-related to `T2` and *cv1* is the same
-cv-qualification as, or greater cv-qualification than, *cv2*. In all
-cases where the reference-related or reference-compatible relationship
-of two types is used to establish the validity of a reference binding,
-and `T1` is a base class of `T2`, a program that necessitates such a
-binding is ill-formed if `T1` is an inaccessible (Clause
-[[class.access]]) or ambiguous ([[class.member.lookup]]) base class of
-`T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
-  - is an lvalue (but is not a bit-field), and “ `T1`” is
-    reference-compatible with “ `T2`,” or
   - has a class type (i.e., `T2` is a class type), where `T1` is not
     reference-related to `T2`, and can be converted to an lvalue of type
-    “ `T3`,” where “ `T1`” is reference-compatible with “ `T3`”[^16]
-    (this conversion is selected by enumerating the applicable
-    conversion functions ([[over.match.ref]]) and choosing the best one
-    through overload resolution ([[over.match]])),
   then the reference is bound to the initializer expression lvalue in
   the first case and to the lvalue result of the conversion in the
   second case (or, in either case, to the appropriate base class
-  subobject of the object). The usual lvalue-to-rvalue ([[conv.lval]]),
   array-to-pointer ([[conv.array]]), and function-to-pointer (
   [[conv.func]]) standard conversions are not needed, and therefore are
-  suppressed, when such direct bindings to lvalues are done.
   ``` cpp
   double d = 2.0;
   double& rd = d;                 // rd refers to d
   const double& rcd = d;          // rcd refers to d
@@ -2076,36 +2616,39 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   struct B : A { operator int&(); } b;
   A& ra = b;                      // ra refers to A subobject in b
   const A& rca = b;               // rca refers to A subobject in b
   int& ir = B();                  // ir refers to the result of B::operator int&
   ```
 - Otherwise, the reference shall be an lvalue reference to a
   non-volatile const type (i.e., *cv1* shall be `const`), or the
   reference shall be an rvalue reference.
   ``` cpp
   double& rd2 = 2.0;              // error: not an lvalue and reference not const
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   - If the initializer expression
-    - is an xvalue (but not a bit-field), class prvalue, array prvalue
- or function lvalue and “*cv1* `T1`” is reference-compatible with
-      “*cv2* `T2`”, or
     - has a class type (i.e., `T2` is a class type), where `T1` is not
-      reference-related to `T2`, and can be converted to an xvalue,
- class prvalue, or function lvalue of type “*cv3* `T3`”, where
- “*cv1* `T1`” is reference-compatible with “*cv3* `T3`” (see
-      [[over.match.ref]]),
-    then the reference is bound to the value of the initializer
- expression in the first case and to the result of the conversion in
- the second case (or, in either case, to an appropriate base class
- subobject). In the second case, if the reference is an rvalue
- reference and the second standard conversion sequence of the
- user-defined conversion sequence includes an lvalue-to-rvalue
- conversion, the program is ill-formed.
     ``` cpp
     struct A { };
     struct B : A { } b;
     extern B f();
     const A& rca2 = f();                // bound to the A subobject of the B rvalue.
@@ -2116,59 +2659,70 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     } x;
     const A& r = x;                     // bound to the A subobject of the result of the conversion
     int i2 = 42;
     int&& rri = static_cast<int&&>(i2); // bound directly to i2
     B&& rrb = x;                        // bound directly to the result of operator B
-    int&& rri2 = X();                   // error: lvalue-to-rvalue conversion applied to the
-                                        // result of operator int&
     ```
   - Otherwise:
-    - If `T1` is a class type, user-defined conversions are considered
- using the rules for copy-initialization of an object of type “
-      `T1`” by user-defined conversion ([[dcl.init]],
-      [[over.match.copy]]); the program is ill-formed if the
       corresponding non-reference copy-initialization would be
       ill-formed. The result of the call to the conversion function, as
       described for the non-reference copy-initialization, is then used
-      to direct-initialize the reference. The program is ill-formed if
- the direct-initialization does not result in a direct binding or
- if it involves a user-defined conversion.
-    - If `T1` is a non-class type, a temporary of type “ `T1`” is
- created and copy-initialized ([[dcl.init]]) from the initializer
- expression. The reference is then bound to the temporary.
     If `T1` is reference-related to `T2`:
     - *cv1* shall be the same cv-qualification as, or greater
       cv-qualification than, *cv2*; and
     - if the reference is an rvalue reference, the initializer
       expression shall not be an lvalue.
     ``` cpp
     struct Banana { };
     struct Enigma { operator const Banana(); };
     void enigmatic() {
       typedef const Banana ConstBanana;
       Banana &&banana1 = ConstBanana(); // ill-formed
       Banana &&banana2 = Enigma();      // ill-formed
     }
     const double& rcd2 = 2;         // rcd2 refers to temporary with value 2.0
     double&& rrd = 2;               // rrd refers to temporary with value 2.0
     const volatile int cvi = 1;
-    const int& r2 = cvi;            // error: type qualifiers dropped
     double d2 = 1.0;
-    double&& rrd2 = d2;             // error: copying lvalue of related type
     int i3 = 2;
     double&& rrd3 = i3;             // rrd3 refers to temporary with value 2.0
     ```
-In all cases except the last (i.e., creating and initializing a
-temporary from the initializer expression), the reference is said to
-*bind directly* to the initializer expression.
-[[class.temporary]] describes the lifetime of temporaries bound to
-references.
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
 *braced-init-list*. Such an initializer is called an *initializer list*,
@@ -2176,24 +2730,30 @@ and the comma-separated *initializer-clause*s of the list are called the
 *elements* of the initializer list. An initializer list may be empty.
 List-initialization can occur in direct-initialization or
 copy-initialization contexts; list-initialization in a
 direct-initialization context is called *direct-list-initialization* and
 list-initialization in a copy-initialization context is called
-*copy-list-initialization*. List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
-- as the initializer in a new expression ([[expr.new]])
 - in a return statement ([[stmt.return]])
 - as a *for-range-initializer* ([[stmt.iter]])
 - as a function argument ([[expr.call]])
 - as a subscript ([[expr.sub]])
 - as an argument to a constructor invocation ([[dcl.init]],
   [[expr.type.conv]])
 - as an initializer for a non-static data member ([[class.mem]])
 - in a *mem-initializer* ([[class.base.init]])
 - on the right-hand side of an assignment ([[expr.ass]])
 ``` cpp
 int a = {1};
 std::complex<double> z{1,2};
 new std::vector<std::string>{"once", "upon", "a", "time"};  // 4 string elements
 f( {"Nicholas","Annemarie"} );  // pass list of two elements
@@ -2201,30 +2761,48 @@ return { "Norah" };             // return list of one element
 int* e {};                      // initialization to zero / null pointer
 x = double{1};                  // explicitly construct a double
 std::map<std::string,int> anim = { {"bear",4}, {"cassowary",2}, {"tiger",7} };
 ```
 A constructor is an *initializer-list constructor* if its first
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
-arguments ([[dcl.fct.default]]). Initializer-list constructors are
-favored over other constructors in list-initialization (
-[[over.match.list]]). Passing an initializer list as the argument to the
-constructor template `template<class T> C(T)` of a class `C` does not
-create an initializer-list constructor, because an initializer list
-argument causes the corresponding parameter to be a non-deduced
-context ([[temp.deduct.call]]). The template `std::initializer_list` is
-not predefined; if the header `<initializer_list>` is not included prior
-to a use of `std::initializer_list` — even an implicit use in which the
-type is not named ([[dcl.spec.auto]]) — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
-- If `T` is an aggregate, aggregate initialization is performed (
- [[dcl.init.aggr]]).
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
@@ -2233,22 +2811,22 @@ follows:
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
 - Otherwise, if the initializer list has no elements and `T` is a class
   type with a default constructor, the object is value-initialized.
-- Otherwise, if `T` is a specialization of `std::initializer_list<E>`, a
- prvalue `initializer_list` object is constructed as described below
-  and used to initialize the object according to the rules for
-  initialization of an object from a class of the same type (
-  [[dcl.init]]).
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
   through overload resolution ([[over.match]],  [[over.match.list]]).
   If a narrowing conversion (see below) is required to convert any of
   the arguments, the program is ill-formed.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(std::initializer_list<int>);    // #2
     S();                              // #3
@@ -2257,17 +2835,21 @@ follows:
   S s1 = { 1.0, 2.0, 3.0 };           // invoke #1
   S s2 = { 1, 2, 3 };                 // invoke #2
   S s3 = { };                         // invoke #3
   ```
   ``` cpp
   struct Map {
     Map(std::initializer_list<std::pair<std::string,int>>);
   };
   Map ship = {{"Sophie",14}, {"Surprise",28}};
   ```
   ``` cpp
   struct S {
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
@@ -2275,25 +2857,61 @@ follows:
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
 - Otherwise, if the initializer list has a single element of type `E`
   and either `T` is not a reference type or its referenced type is
   reference-related to `E`, the object or reference is initialized from
-  that element; if a narrowing conversion (see below) is required to
- convert the element to `T`, the program is ill-formed.
   ``` cpp
   int x1 {2};                         // OK
   int x2 {2.0};                       // error: narrowing
   ```
-- Otherwise, if `T` is a reference type, a prvalue temporary of the type
- referenced by `T` is copy-list-initialized or direct-list-initialized,
-  depending on the kind of initialization for the reference, and the
- reference is bound to that temporary. As usual, the binding will fail
- and the program is ill-formed if the reference type is an lvalue
- reference to a non-const type.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
@@ -2303,16 +2921,22 @@ follows:
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
 - Otherwise, the program is ill-formed.
   ``` cpp
   struct A { int i; int j; };
   A a1 { 1, 2 };                      // aggregate initialization
   A a2 { 1.2 };                       // error: narrowing
   struct B {
@@ -2328,32 +2952,42 @@ follows:
   int j { 1 };                        // initialize to 1
   int k { };                          // initialize to 0
   ```
 Within the *initializer-list* of a *braced-init-list*, the
 *initializer-clause*s, including any that result from pack expansions (
 [[temp.variadic]]), are evaluated in the order in which they appear.
 That is, every value computation and side effect associated with a given
 *initializer-clause* is sequenced before every value computation and
 side effect associated with any *initializer-clause* that follows it in
-the comma-separated list of the *initializer-list*. This evaluation
-ordering holds regardless of the semantics of the initialization; for
-example, it applies when the elements of the *initializer-list* are
-interpreted as arguments of a constructor call, even though ordinarily
-there are no sequencing constraints on the arguments of a call.
 An object of type `std::initializer_list<E>` is constructed from an
-initializer list as if the implementation allocated a temporary array of
-N elements of type `const E`, where N is the number of elements in the
-initializer list. Each element of that array is copy-initialized with
-the corresponding element of the initializer list, and the
-`std::initializer_list<E>` object is constructed to refer to that array.
-A constructor or conversion function selected for the copy shall be
-accessible (Clause  [[class.access]]) in the context of the initializer
-list. If a narrowing conversion is required to initialize any of the
-elements, the program is ill-formed.
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
@@ -2369,15 +3003,19 @@ X x(std::initializer_list<double>(__a, __a+3));
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
 The array has the same lifetime as any other temporary object (
 [[class.temporary]]), except that initializing an `initializer_list`
 object from the array extends the lifetime of the array exactly like
 binding a reference to a temporary.
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
@@ -2385,24 +3023,27 @@ void f() {
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
 struct A {
   std::initializer_list<int> i4;
-  A() : i4{ 1, 2, 3 } {}  // creates an A with a dangling reference
 };
 ```
 For `v1` and `v2`, the `initializer_list` object is a parameter in a
 function call, so the array created for `{ 1, 2, 3 }` has
 full-expression lifetime. For `i3`, the `initializer_list` object is a
 variable, so the array persists for the lifetime of the variable. For
-`i4`, the `initializer_list` object is initialized in a constructor’s
-*ctor-initializer*, so the array persists only until the constructor
-exits, and so any use of the elements of `i4` after the constructor
-exits produces undefined behavior. The implementation is free to
-allocate the array in read-only memory if an explicit array with the
-same initializer could be so allocated.
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from `long double` to `double` or `float`, or from `double` to
@@ -2416,12 +3057,14 @@ A *narrowing conversion* is an implicit conversion
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
   where the source is a constant expression whose value after integral
   promotions will fit into the target type.
-As indicated above, such conversions are not allowed at the top level in
-list-initializations.
 ``` cpp
 int x = 999;              // x is not a constant expression
 const int y = 999;
 const int z = 99;
@@ -2440,34 +3083,41 @@ float f2 { 7 };           // OK: 7 can be exactly represented as a float
 int f(int);
 int a[] =
   { 2, f(2), f(2.0) };    // OK: the double-to-int conversion is not at the top level
 ```
 <!-- Link reference definitions -->
 [basic.compound]: basic.md#basic.compound
 [basic.def]: basic.md#basic.def
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
-[basic.start.init]: basic.md#basic.start.init
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [basic.types]: basic.md#basic.types
 [class]: class.md#class
@@ -2477,43 +3127,49 @@ int a[] =
 [class.conv]: special.md#class.conv
 [class.conv.ctor]: special.md#class.conv.ctor
 [class.conv.fct]: special.md#class.conv.fct
 [class.copy]: special.md#class.copy
 [class.ctor]: special.md#class.ctor
-[class.derived]: class.md#class.derived
 [class.dtor]: special.md#class.dtor
 [class.expl.init]: special.md#class.expl.init
 [class.friend]: class.md#class.friend
-[class.inhctor]: special.md#class.inhctor
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
-[class.this]: class.md#class.this
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
 [conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [dcl.enum]: #dcl.enum
 [dcl.fct]: #dcl.fct
@@ -2527,25 +3183,28 @@ int a[] =
 [dcl.init]: #dcl.init
 [dcl.init.aggr]: #dcl.init.aggr
 [dcl.init.list]: #dcl.init.list
 [dcl.init.ref]: #dcl.init.ref
 [dcl.init.string]: #dcl.init.string
 [dcl.link]: #dcl.link
 [dcl.meaning]: #dcl.meaning
 [dcl.mptr]: #dcl.mptr
 [dcl.name]: #dcl.name
 [dcl.ptr]: #dcl.ptr
 [dcl.ref]: #dcl.ref
 [dcl.spec]: #dcl.spec
 [dcl.spec.auto]: #dcl.spec.auto
 [dcl.stc]: #dcl.stc
 [dcl.type]: #dcl.type
 [dcl.type.cv]: #dcl.type.cv
 [dcl.type.elab]: #dcl.type.elab
 [dcl.type.simple]: #dcl.type.simple
 [dcl.typedef]: #dcl.typedef
-[depr.register]: future.md#depr.register
 [except.handle]: except.md#except.handle
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.alignof]: expr.md#expr.alignof
@@ -2556,18 +3215,18 @@ int a[] =
 [expr.cond]: expr.md#expr.cond
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
-[expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [expr.unary.op]: expr.md#expr.unary.op
-[global.names]: library.md#global.names
 [intro.compliance]: intro.md#intro.compliance
 [intro.execution]: intro.md#intro.execution
 [intro.multithread]: intro.md#intro.multithread
 [lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
@@ -2581,30 +3240,34 @@ int a[] =
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
 [over.match]: over.md#over.match
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
 [over.match.ref]: over.md#over.match.ref
 [over.oper]: over.md#over.oper
 [over.sub]: over.md#over.sub
 [stmt.ambig]: stmt.md#stmt.ambig
-[stmt.block]: stmt.md#stmt.block
 [stmt.dcl]: stmt.md#stmt.dcl
-[stmt.for]: stmt.md#stmt.for
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.return]: stmt.md#stmt.return
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.inst]: temp.md#temp.inst
@@ -2615,11 +3278,11 @@ int a[] =
 [temp.spec]: temp.md#temp.spec
 [temp.variadic]: temp.md#temp.variadic
 [^1]: The “implicit int” rule of C is no longer supported.
-[^2]: The inline keyword has no effect on the linkage of a function.
 [^3]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
@@ -2627,88 +3290,46 @@ int a[] =
 [^4]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
-[^5]: Although entities in an unnamed namespace might have external
-    linkage, they are effectively qualified by a name unique to their
-    translation unit and therefore can never be seen from any other
-    translation unit.
-[^6]: this implies that the name of the class or function is
     unqualified.
 [^7]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
-[^8]: A declaration with several declarators is usually equivalent to
-    the corresponding sequence of declarations each with a single
-    declarator. That is
-    `T  D1, D2, ... Dn;`
-    is usually equivalent to
-    `T  D1; T D2; ... T Dn;`
-    where `T` is a *decl-specifier-seq* and each `Di` is an
-    *init-declarator*. An exception occurs when a name introduced by one
-    of the *declarator*s hides a type name used by the
-    *decl-specifiers*, so that when the same *decl-specifiers* are used
-    in a subsequent declaration, they do not have the same meaning, as
-    in
-    `struct S { ... };`
-    `S S, T; \textrm{// declare two instances of \tcode{struct S}}`
-    which is not equivalent to
-    `struct S { ... };`
-    `S S;`
-    `S T; \textrm{// error}`
-    Another exception occurs when `T` is `auto` ([[dcl.spec.auto]]),
-    for example:
-    `auto i = 1, j = 2.0; \textrm{// error: deduced types for \tcode{i} and \tcode{j} do not match}`
-    as opposed to
-    `auto i = 1;    \textrm{// OK: \tcode{i} deduced to have type \tcode{int}}`
-    `auto j = 2.0;  \textrm{// OK: \tcode{j} deduced to have type \tcode{double}}`
-[^9]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
-[^10]: This excludes parameters of type “ `T2`” where `T2` is “pointer
-    to array of unknown bound of `T`” and where means any sequence of
-    “pointer to” and “array of” derived declarator types. This exclusion
-    applies to the parameters of the function, and if a parameter is a
-    pointer to function or pointer to member function then to its
-    parameters also, etc.
-[^11]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
-[^12]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
-[^13]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
-    [[global.names]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
-[^14]: As specified in  [[conv.ptr]], converting an integer literal
     whose value is `0` to a pointer type results in a null pointer
     value.
-[^15]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
-[^16]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

 to) and `()` (function returning). Initial values can also be specified
 in a declarator; initializers are discussed in  [[dcl.init]] and
 [[class.init]].
 Each *init-declarator* in a declaration is analyzed separately as if it
+was in a declaration by itself.
+[*Note 1*:
+A declaration with several declarators is usually equivalent to the
+corresponding sequence of declarations each with a single declarator.
+That is
+``` cpp
+T D1, D2, ... Dn;
+```
+is usually equivalent to
+``` cpp
+T D1; T D2; ... T Dn;
+```
+where `T` is a *decl-specifier-seq* and each `Di` is an
+*init-declarator*. One exception is when a name introduced by one of the
+*declarator*s hides a type name used by the *decl-specifier*s, so that
+when the same *decl-specifier*s are used in a subsequent declaration,
+they do not have the same meaning, as in
+``` cpp
+struct S { ... };
+S S, T;                 // declare two instances of struct S
+```
+which is not equivalent to
+``` cpp
+struct S { ... };
+S S;
+S T;                    // error
+```
+Another exception is when `T` is `auto` ([[dcl.spec.auto]]), for
+example:
+``` cpp
+auto i = 1, j = 2.0;    // error: deduced types for i and j do not match
+```
+as opposed to
+``` cpp
+auto i = 1;             // OK: i deduced to have type int
+auto j = 2.0;           // OK: j deduced to have type double
+```
+— *end note*]
 Declarators have the syntax
 ``` bnf
 declarator:
 ```
 ``` bnf
 parameters-and-qualifiers:
     '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
+  ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 ``` bnf
 trailing-return-type:
+    '->' type-id
 ```
 ``` bnf
 ptr-operator:
     '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ
 ``` bnf
 declarator-id:
     '...'ₒₚₜ id-expression
 ```
 ## Type names <a id="dcl.name">[[dcl.name]]</a>
 To specify type conversions explicitly, and as an argument of `sizeof`,
 `alignof`, `new`, or `typeid`, the name of a type shall be specified.
 This can be done with a *type-id*, which is syntactically a declaration
 ``` bnf
 type-id:
     type-specifier-seq abstract-declaratorₒₚₜ
 ```
+``` bnf
+defining-type-id:
+    defining-type-specifier-seq abstract-declaratorₒₚₜ
+```
 ``` bnf
 abstract-declarator:
     ptr-abstract-declarator
     noptr-abstract-declaratorₒₚₜ parameters-and-qualifiers trailing-return-type
     abstract-pack-declarator
 It is possible to identify uniquely the location in the
 *abstract-declarator* where the identifier would appear if the
 construction were a declarator in a declaration. The named type is then
 the same as the type of the hypothetical identifier.
+[*Example 1*:
 ``` cpp
 int                 // int i
 int *               // int *pi
 int *[3]            // int *p[3]
 int (*)[3]          // int (*p3i)[3]
 int *()             // int *f()
 int (*)(double)     // int (*pf)(double)
 ```
+name respectively the types “`int`”, “pointer to `int`”, “array of 3
+pointers to `int`”, “pointer to array of 3 `int`”, “function of (no
+parameters) returning pointer to `int`”, and “pointer to a function of
+(`double`) returning `int`”.
+— *end example*]
+A type can also be named (often more easily) by using a `typedef` (
 [[dcl.typedef]]).
 ## Ambiguity resolution <a id="dcl.ambig.res">[[dcl.ambig.res]]</a>
 The ambiguity arising from the similarity between a function-style cast
 context of a declaration. In that context, the choice is between a
 function declaration with a redundant set of parentheses around a
 parameter name and an object declaration with a function-style cast as
 the initializer. Just as for the ambiguities mentioned in
 [[stmt.ambig]], the resolution is to consider any construct that could
+possibly be a declaration a declaration.
+[*Note 1*: A declaration can be explicitly disambiguated by adding
+parentheses around the argument. The ambiguity can be avoided by use of
+copy-initialization or list-initialization syntax, or by use of a
+non-function-style cast. — *end note*]
+[*Example 1*:
 ``` cpp
 struct S {
   S(int);
 };
 void foo(double a) {
   S w(int(a));                  // function declaration
   S x(int());                   // function declaration
+  S y((int(a)));                // object declaration
   S y((int)a);                  // object declaration
   S z = int(a);                 // object declaration
 }
 ```
+— *end example*]
+An ambiguity can arise from the similarity between a function-style cast
+and a *type-id*. The resolution is that any construct that could
+possibly be a *type-id* in its syntactic context shall be considered a
+*type-id*.
+[*Example 2*:
 ``` cpp
+template <class T> struct X {};
+template <int N> struct Y {};
+X<int()> a;                     // type-id
+X<int(1)> b;                    // expression (ill-formed)
+Y<int()> c;                     // type-id (ill-formed)
+Y<int(1)> d;                    // expression
+void foo(signed char a) {
   sizeof(int());                // type-id (ill-formed)
+  sizeof(int(a));               // expression
+  sizeof(int(unsigned(a)));     // type-id (ill-formed)
+  (int())+1;                    // type-id (ill-formed)
+  (int(a))+1;                   // expression
+  (int(unsigned(a)))+1;         // type-id (ill-formed)
 }
 ```
+— *end example*]
+Another ambiguity arises in a *parameter-declaration-clause* when a
+*type-name* is nested in parentheses. In this case, the choice is
+between the declaration of a parameter of type pointer to function and
+the declaration of a parameter with redundant parentheses around the
+*declarator-id*. The resolution is to consider the *type-name* as a
+*simple-type-specifier* rather than a *declarator-id*.
+[*Example 3*:
 ``` cpp
 class C { };
 void f(int(C)) { }              // void f(int(*fp)(C c)) { }
+                                // not: void f(int C) { }
 int g(C);
 void foo() {
   f(1);                         // error: cannot convert 1 to function pointer
 class C { };
 void h(int *(C[10]));           // void h(int *(*_fp)(C _parm[10]));
                                 // not: void h(int *C[10]);
 ```
+— *end example*]
 ## Meaning of declarators <a id="dcl.meaning">[[dcl.meaning]]</a>
+A declarator contains exactly one *declarator-id*; it names the
+identifier that is declared. An *unqualified-id* occurring in a
+*declarator-id* shall be a simple *identifier* except for the
+declaration of some special functions ([[class.ctor]], [[class.conv]],
+[[class.dtor]], [[over.oper]]) and for the declaration of template
+specializations or partial specializations ([[temp.spec]]). When the
+*declarator-id* is qualified, the declaration shall refer to a
+previously declared member of the class or namespace to which the
+qualifier refers (or, in the case of a namespace, of an element of the
+inline namespace set of that namespace ([[namespace.def]])) or to a
+specialization thereof; the member shall not merely have been introduced
+by a *using-declaration* in the scope of the class or namespace
+nominated by the *nested-name-specifier* of the *declarator-id*. The
+*nested-name-specifier* of a qualified *declarator-id* shall not begin
+with a *decltype-specifier*.
+[*Note 1*: If the qualifier is the global `::` scope resolution
+operator, the *declarator-id* refers to a name declared in the global
+namespace scope. — *end note*]
 The optional *attribute-specifier-seq* following a *declarator-id*
 appertains to the entity that is declared.
+A `static`, `thread_local`, `extern`, `mutable`, `friend`, `inline`,
+`virtual`, `constexpr`, `explicit`, or `typedef` specifier applies
+directly to each *declarator-id* in an *init-declarator-list* or
+*member-declarator-list*; the type specified for each *declarator-id*
+depends on both the *decl-specifier-seq* and its *declarator*.
 Thus, a declaration of a particular identifier has the form
 ``` cpp
 T D
 ```
+where `T` is of the form *attribute-specifier-seq*ₒₚₜ
 *decl-specifier-seq* and `D` is a declarator. Following is a recursive
 procedure for determining the type specified for the contained
 *declarator-id* by such a declaration.
 First, the *decl-specifier-seq* determines a type. In a declaration
 ``` cpp
 T D
 ```
+the *decl-specifier-seq* `T` determines the type `T`.
+[*Example 1*:
+In the declaration
 ``` cpp
 int unsigned i;
 ```
 the type specifiers `int` `unsigned` determine the type “`unsigned int`”
 ([[dcl.type.simple]]).
+— *end example*]
+In a declaration *attribute-specifier-seq*ₒₚₜ  `T` `D` where `D` is an
 unadorned identifier the type of this identifier is “`T`”.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
+'(' 'D1' ')'
 ```
 the type of the contained *declarator-id* is the same as that of the
 contained *declarator-id* in the declaration
 ``` bnf
 '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
+and the type of the identifier in the declaration `T` `D1` is
+“*derived-declarator-type-list* `T`”, then the type of the identifier of
+`D` is “*derived-declarator-type-list* *cv-qualifier-seq* pointer to
+`T`”. The *cv-qualifier*s apply to the pointer and not to the object
+pointed to. Similarly, the optional *attribute-specifier-seq* (
 [[dcl.attr.grammar]]) appertains to the pointer and not to the object
 pointed to.
+[*Example 1*:
+The declarations
 ``` cpp
 const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
 int i, *p, *const cp = &i;
 ```
 Each is unacceptable because it would either change the value of an
 object declared `const` or allow it to be changed through a
 cv-unqualified pointer later, for example:
 ``` cpp
+*ppc = &ci;         // OK, but would make p point to ci because of previous error
 *p = 5;             // clobber ci
 ```
+— *end example*]
 See also  [[expr.ass]] and  [[dcl.init]].
+[*Note 1*: Forming a pointer to reference type is ill-formed; see
+[[dcl.ref]]. Forming a function pointer type is ill-formed if the
+function type has *cv-qualifier*s or a *ref-qualifier*; see
+[[dcl.fct]]. Since the address of a bit-field ([[class.bit]]) cannot be
+taken, a pointer can never point to a bit-field. — *end note*]
 ### References <a id="dcl.ref">[[dcl.ref]]</a>
 In a declaration `T` `D` where `D` has either of the forms
 ``` bnf
 '&' attribute-specifier-seqₒₚₜ 'D1'
 '&&' attribute-specifier-seqₒₚₜ 'D1'
 ```
+and the type of the identifier in the declaration `T` `D1` is
+“*derived-declarator-type-list* `T`”, then the type of the identifier of
+`D` is “*derived-declarator-type-list* reference to `T`”. The optional
+*attribute-specifier-seq* appertains to the reference type. Cv-qualified
+references are ill-formed except when the cv-qualifiers are introduced
+through the use of a *typedef-name* ([[dcl.typedef]], [[temp.param]])
+or *decltype-specifier* ([[dcl.type.simple]]), in which case the
+cv-qualifiers are ignored.
+[*Example 1*:
 ``` cpp
 typedef int& A;
 const A aref = 3;   // ill-formed; lvalue reference to non-const initialized with rvalue
 ```
 The type of `aref` is “lvalue reference to `int`”, not “lvalue reference
+to `const int`”.
+— *end example*]
+[*Note 1*: A reference can be thought of as a name of an
+object. — *end note*]
+A declarator that specifies the type “reference to cv `void`” is
 ill-formed.
 A reference type that is declared using `&` is called an *lvalue
 reference*, and a reference type that is declared using `&&` is called
 an *rvalue reference*. Lvalue references and rvalue references are
 distinct types. Except where explicitly noted, they are semantically
 equivalent and commonly referred to as references.
+[*Example 2*:
 ``` cpp
 void f(double& a) { a += 3.14; }
 // ...
 double d = 0;
 f(d);
 ```
 declares `p` to be a reference to a pointer to `link` so `h(q)` will
 leave `q` with the value zero. See also  [[dcl.init.ref]].
+— *end example*]
 It is unspecified whether or not a reference requires storage (
 [[basic.stc]]).
 There shall be no references to references, no arrays of references, and
 no pointers to references. The declaration of a reference shall contain
 an *initializer* ([[dcl.init.ref]]) except when the declaration
 contains an explicit `extern` specifier ([[dcl.stc]]), is a class
 member ([[class.mem]]) declaration within a class definition, or is the
 declaration of a parameter or a return type ([[dcl.fct]]); see
 [[basic.def]]. A reference shall be initialized to refer to a valid
+object or function.
+[*Note 2*:  In particular, a null reference cannot exist in a
 well-defined program, because the only way to create such a reference
 would be to bind it to the “object” obtained by indirection through a
 null pointer, which causes undefined behavior. As described in
+[[class.bit]], a reference cannot be bound directly to a
+bit-field. — *end note*]
 If a *typedef-name* ([[dcl.typedef]], [[temp.param]]) or a
 *decltype-specifier* ([[dcl.type.simple]]) denotes a type `TR` that is
 a reference to a type `T`, an attempt to create the type “lvalue
 reference to cv `TR`” creates the type “lvalue reference to `T`”, while
 an attempt to create the type “rvalue reference to cv `TR`” creates the
 type `TR`.
+[*Note 3*: This rule is known as reference collapsing. — *end note*]
+[*Example 3*:
 ``` cpp
 int i;
 typedef int& LRI;
 typedef int&& RRI;
 decltype(r2)& r6 = i;           // r6 has the type int&
 decltype(r2)&& r7 = i;          // r7 has the type int&
 ```
+— *end example*]
+[*Note 4*: Forming a reference to function type is ill-formed if the
+function type has *cv-qualifier*s or a *ref-qualifier*; see
+[[dcl.fct]]. — *end note*]
 ### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
+nested-name-specifier '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
 and the *nested-name-specifier* denotes a class, and the type of the
+identifier in the declaration `T` `D1` is
+“*derived-declarator-type-list* `T`”, then the type of the identifier of
+`D` is “*derived-declarator-type-list* *cv-qualifier-seq* pointer to
+member of class *nested-name-specifier* of type `T`”. The optional
+*attribute-specifier-seq* ([[dcl.attr.grammar]]) appertains to the
+pointer-to-member.
+[*Example 1*:
 ``` cpp
 struct X {
   void f(int);
   int a;
 type. `pmi` and `pmf` can be used like this:
 ``` cpp
 X obj;
 // ...
+obj.*pmi = 7;       // assign 7 to an integer member of obj
+(obj.*pmf)(7);      // call a function member of obj with the argument 7
 ```
+— *end example*]
 A pointer to member shall not point to a static member of a class (
+[[class.static]]), a member with reference type, or “cv `void`”.
+[*Note 1*: See also  [[expr.unary]] and  [[expr.mptr.oper]]. The type
+“pointer to member” is distinct from the type “pointer”, that is, a
+pointer to member is declared only by the pointer to member declarator
+syntax, and never by the pointer declarator syntax. There is no
+“reference-to-member” type in C++. — *end note*]
 ### Arrays <a id="dcl.array">[[dcl.array]]</a>
 In a declaration `T` `D` where `D` has the form
 ```
 and the type of the identifier in the declaration `T` `D1` is
 “*derived-declarator-type-list* `T`”, then the type of the identifier of
 `D` is an array type; if the type of the identifier of `D` contains the
+`auto` *type-specifier*, the program is ill-formed. `T` is called the
+array *element type*; this type shall not be a reference type,
+cv `void`, a function type or an abstract class type. If the
+*constant-expression* ([[expr.const]]) is present, it shall be a
 converted constant expression of type `std::size_t` and its value shall
 be greater than zero. The constant expression specifies the *bound* of
 (number of elements in) the array. If the value of the constant
 expression is `N`, the array has `N` elements numbered `0` to `N-1`, and
+the type of the identifier of `D` is “*derived-declarator-type-list*
+array of `N` `T`”. An object of array type contains a contiguously
+allocated non-empty set of `N` subobjects of type `T`. Except as noted
+below, if the constant expression is omitted, the type of the identifier
+of `D` is “*derived-declarator-type-list* array of unknown bound of
+`T`”, an incomplete object type. The type
+“*derived-declarator-type-list* array of `N` `T`” is a different type
+from the type “*derived-declarator-type-list* array of unknown bound of
+`T`”, see  [[basic.types]]. Any type of the form “*cv-qualifier-seq*
+array of `N` `T`” is adjusted to “array of `N` *cv-qualifier-seq* `T`”,
+and similarly for “array of unknown bound of `T`”. The optional
+*attribute-specifier-seq* appertains to the array.
+[*Example 1*:
 ``` cpp
 typedef int A[5], AA[2][3];
 typedef const A CA;             // type is ``array of 5 const int''
 typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
 ```
+— *end example*]
+[*Note 1*: An “array of `N` *cv-qualifier-seq* `T`” has cv-qualified
+type; see  [[basic.type.qualifier]]. — *end note*]
 An array can be constructed from one of the fundamental types (except
 `void`), from a pointer, from a pointer to member, from a class, from an
 enumeration type, or from another array.
 When several “array of” specifications are adjacent, a multidimensional
+array type is created; only the first of the constant expressions that
 specify the bounds of the arrays may be omitted. In addition to
 declarations in which an incomplete object type is allowed, an array
 bound may be omitted in some cases in the declaration of a function
 parameter ([[dcl.fct]]). An array bound may also be omitted when the
+declarator is followed by an *initializer* ([[dcl.init]]) or when a
+declarator for a static data member is followed by a
+*brace-or-equal-initializer* ([[class.mem]]). In both cases the bound
+is calculated from the number of initial elements (say, `N`) supplied (
+[[dcl.init.aggr]]), and the type of the identifier of `D` is “array of
+`N` `T`”. Furthermore, if there is a preceding declaration of the entity
+in the same scope in which the bound was specified, an omitted array
+bound is taken to be the same as in that earlier declaration, and
+similarly for the definition of a static data member of a class.
+[*Example 2*:
 ``` cpp
 float fa[17], *afp[17];
 ```
   extern int x[];
   int i = sizeof(x);    // error: incomplete object type
 }
 ```
+— *end example*]
+[*Note 2*: Conversions affecting expressions of array type are
+described in  [[conv.array]]. Objects of array types cannot be modified,
+see  [[basic.lval]]. — *end note*]
+[*Note 3*: Except where it has been declared for a class (
+[[over.sub]]), the subscript operator `[]` is interpreted in such a way
+that `E1[E2]` is identical to `*((E1)+(E2))` ([[expr.sub]]). Because of
+the conversion rules that apply to `+`, if `E1` is an array and `E2` an
+integer, then `E1[E2]` refers to the `E2`-th member of `E1`. Therefore,
+despite its asymmetric appearance, subscripting is a commutative
+operation. — *end note*]
+[*Note 4*:
 A consistent rule is followed for multidimensional arrays. If `E` is an
 *n*-dimensional array of rank i × j × … × k, then `E` appearing in an
 expression that is subject to the array-to-pointer conversion (
 [[conv.array]]) is converted to a pointer to an (n-1)-dimensional array
 with rank j × … × k. If the `*` operator, either explicitly or
 implicitly as a result of subscripting, is applied to this pointer, the
 result is the pointed-to (n-1)-dimensional array, which itself is
 immediately converted into a pointer.
+[*Example 3*:
+Consider
 ``` cpp
 int x[3][5];
 ```
 namely five integer objects. The results are added and indirection
 applied to yield an array (of five integers), which in turn is converted
 to a pointer to the first of the integers. If there is another subscript
 the same argument applies again; this time the result is an integer.
+— *end example*]
+— *end note*]
+[*Note 5*: It follows from all this that arrays in C++are stored
+row-wise (last subscript varies fastest) and that the first subscript in
+the declaration helps determine the amount of storage consumed by an
+array but plays no other part in subscript calculations. — *end note*]
 ### Functions <a id="dcl.fct">[[dcl.fct]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
+  ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, the type of the
+*declarator-id* in `D` is “*derived-declarator-type-list* `noexcept`
+function of (*parameter-declaration-clause*) *cv-qualifier-seq*ₒₚₜ
+*ref-qualifier*ₒₚₜ  returning `T`”, where the optional `noexcept` is
+present if and only if the exception specification ([[except.spec]]) is
+non-throwing. The optional *attribute-specifier-seq* appertains to the
+function type.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
+  ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-type
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, `T` shall be the single
 *type-specifier* `auto`. The type of the *declarator-id* in `D` is
+“*derived-declarator-type-list* `noexcept` function of
+(*parameter-declaration-clause*) *cv-qualifier-seq**ref-qualifier*
+returning `U`”, where `U` is the type specified by the
+*trailing-return-type*, and where the optional `noexcept` is present if
+and only if the exception specification is non-throwing. The optional
 *attribute-specifier-seq* appertains to the function type.
+A type of either form is a *function type*.[^8]
 ``` bnf
 parameter-declaration-clause:
+    parameter-declaration-listₒₚₜ '...'ₒₚₜ
+    parameter-declaration-list ', ...'
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
 The *parameter-declaration-clause* determines the arguments that can be
+specified, and their processing, when the function is called.
+[*Note 1*:  The *parameter-declaration-clause* is used to convert the
+arguments specified on the function call; see
+[[expr.call]]. — *end note*]
+If the *parameter-declaration-clause* is empty, the function takes no
 arguments. A parameter list consisting of a single unnamed parameter of
 non-dependent type `void` is equivalent to an empty parameter list.
 Except for this special case, a parameter shall not have type *cv*
 `void`. If the *parameter-declaration-clause* terminates with an
 ellipsis or a function parameter pack ([[temp.variadic]]), the number
 of arguments shall be equal to or greater than the number of parameters
 that do not have a default argument and are not function parameter
+packs. Where syntactically correct and where “`...`” is not part of an
+*abstract-declarator*, “`, ...`” is synonymous with “`...`”.
+[*Example 1*:
+The declaration
 ``` cpp
 int printf(const char*, ...);
 ```
 printf("hello world");
 printf("a=%d b=%d", a, b);
 ```
 However, the first argument must be of a type that can be converted to a
+`const` `char*`
+— *end example*]
+[*Note 2*: The standard header `<cstdarg>` contains a mechanism for
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
+[[support.runtime]]). — *end note*]
 A single name can be used for several different functions in a single
 scope; this is function overloading (Clause  [[over]]). All declarations
 for a function shall agree exactly in both the return type and the
 parameter-type-list. The type of a function is determined using the
 following rules. The type of each parameter (including function
 parameter packs) is determined from its own *decl-specifier-seq* and
 *declarator*. After determining the type of each parameter, any
+parameter of type “array of `T`” or of function type `T` is adjusted to
+be “pointer to `T`”. After producing the list of parameter types, any
+top-level *cv-qualifier*s modifying a parameter type are deleted when
+forming the function type. The resulting list of transformed parameter
+types and the presence or absence of the ellipsis or a function
+parameter pack is the function’s *parameter-type-list*.
+[*Note 3*: This transformation does not affect the types of the
+parameters. For example, `int(*)(const int p, decltype(p)*)` and
+`int(*)(int, const int*)` are identical types. — *end note*]
 A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 (including a type named by *typedef-name* ([[dcl.typedef]],
 [[temp.param]])) shall appear only as:
 - the *type-id* in the default argument of a *type-parameter* (
   [[temp.param]]), or
 - the *type-id* of a *template-argument* for a *type-parameter* (
   [[temp.arg.type]]).
+[*Example 2*:
 ``` cpp
 typedef int FIC(int) const;
 FIC f;              // ill-formed: does not declare a member function
 struct S {
   FIC f;            // OK
 };
 FIC S::*pm = &S::f; // OK
 ```
+— *end example*]
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 same as adding cv-qualification on top of the function type. In the
+latter case, the cv-qualifiers are ignored.
+[*Note 4*: A function type that has a *cv-qualifier-seq* is not a
+cv-qualified type; there are no cv-qualified function
+types. — *end note*]
+[*Example 3*:
 ``` cpp
 typedef void F();
 struct S {
   const F f;        // OK: equivalent to: void f();
 };
 ```
+— *end example*]
+The return type, the parameter-type-list, the *ref-qualifier*, the
+*cv-qualifier-seq*, and the exception specification, but not the default
+arguments ([[dcl.fct.default]]), are part of the function type.
+[*Note 5*: Function types are checked during the assignments and
 initializations of pointers to functions, references to functions, and
+pointers to member functions. — *end note*]
+[*Example 4*:
+The declaration
 ``` cpp
 int fseek(FILE*, long, int);
 ```
 declares a function taking three arguments of the specified types, and
 returning `int` ([[dcl.type]]).
+— *end example*]
+Functions shall not have a return type of type array or function,
+although they may have a return type of type pointer or reference to
+such things. There shall be no arrays of functions, although there can
+be arrays of pointers to functions.
 Types shall not be defined in return or parameter types. The type of a
 parameter or the return type for a function definition shall not be an
+incomplete (possibly cv-qualified) class type in the context of the
+function definition unless the function is deleted (
+[[dcl.fct.def.delete]]).
 A typedef of function type may be used to declare a function but shall
 not be used to define a function ([[dcl.fct.def]]).
+[*Example 5*:
 ``` cpp
 typedef void F();
 F  fv;              // OK: equivalent to void fv();
 F  fv { }           // ill-formed
 void fv() { }       // OK: definition of fv
 ```
+— *end example*]
 An identifier can optionally be provided as a parameter name; if present
+in a function definition ([[dcl.fct.def]]), it names a parameter.
+[*Note 6*: In particular, parameter names are also optional in function
+definitions and names used for a parameter in different declarations and
+the definition of a function need not be the same. If a parameter name
+is present in a function declaration that is not a definition, it cannot
+be used outside of its function declarator because that is the extent of
+its potential scope ([[basic.scope.proto]]). — *end note*]
+[*Example 6*:
+The declaration
 ``` cpp
 int i,
     *pi,
     f(),
 suggests, and the same construction in an expression requires, the
 calling of a function `fpi`, and then using indirection through the
 (pointer) result to yield an integer. In the declarator
 `(*pif)(const char*, const char*)`, the extra parentheses are necessary
 to indicate that indirection through a pointer to a function yields a
+function, which is then called.
+— *end example*]
+[*Note 7*:
+Typedefs and *trailing-return-type*s are sometimes convenient when the
+return type of a function is complex. For example, the function `fpif`
+above could have been declared
 ``` cpp
 typedef int  IFUNC(int);
 IFUNC*  fpif(int);
 ```
 ``` cpp
 template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);
 ```
+— *end note*]
 A *non-template function* is a function that is not a function template
+specialization.
+[*Note 8*: A function template is not a function. — *end note*]
 A *declarator-id* or *abstract-declarator* containing an ellipsis shall
 only be used in a *parameter-declaration*. Such a
 *parameter-declaration* is a parameter pack ([[temp.variadic]]). When
 it is part of a *parameter-declaration-clause*, the parameter pack is a
+function parameter pack ([[temp.variadic]]).
+[*Note 9*: Otherwise, the *parameter-declaration* is part of a
+*template-parameter-list* and the parameter pack is a template parameter
+pack; see  [[temp.param]]. — *end note*]
+A function parameter pack is a pack expansion ([[temp.variadic]]).
+[*Example 7*:
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
 void g() {
   f(add, subtract);
 }
 ```
+— *end example*]
 There is a syntactic ambiguity when an ellipsis occurs at the end of a
 *parameter-declaration-clause* without a preceding comma. In this case,
 the ellipsis is parsed as part of the *abstract-declarator* if the type
 of the parameter either names a template parameter pack that has not
 been expanded or contains `auto`; otherwise, it is parsed as part of the
+*parameter-declaration-clause*.[^9]
 ### Default arguments <a id="dcl.fct.default">[[dcl.fct.default]]</a>
 If an *initializer-clause* is specified in a *parameter-declaration*
 this *initializer-clause* is used as a default argument. Default
 arguments will be used in calls where trailing arguments are missing.
+[*Example 1*:
+The declaration
 ``` cpp
 void point(int = 3, int = 4);
 ```
 ```
 The last two calls are equivalent to `point(1,4)` and `point(3,4)`,
 respectively.
+— *end example*]
 A default argument shall be specified only in the
+*parameter-declaration-clause* of a function declaration or
+*lambda-declarator* or in a *template-parameter* ([[temp.param]]); in
+the latter case, the *initializer-clause* shall be an
+*assignment-expression*. A default argument shall not be specified for a
+parameter pack. If it is specified in a *parameter-declaration-clause*,
+it shall not occur within a *declarator* or *abstract-declarator* of a
+*parameter-declaration*.[^10]
 For non-template functions, default arguments can be added in later
 declarations of a function in the same scope. Declarations in different
 scopes have completely distinct sets of default arguments. That is,
 declarations in inner scopes do not acquire default arguments from
 argument shall have a default argument supplied in this or a previous
 declaration or shall be a function parameter pack. A default argument
 shall not be redefined by a later declaration (not even to the same
 value).
+[*Example 2*:
 ``` cpp
 void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
                                 // a parameter with a default argument
 void f(int, int);
 void f(int, int = 7);
 void h() {
   f(3);                         // OK, calls f(3, 7)
+  void f(int = 1, int);         // error: does not use default from surrounding scope
 }
 void m() {
   void f(int, int);             // has no defaults
   f(4);                         // error: wrong number of arguments
   void f(int, int = 5);         // OK
   f(4);                         // OK, calls f(4, 5);
+  void f(int, int = 5);         // error: cannot redefine, even to same value
 }
 void n() {
   f(6);                         // OK, calls f(6, 7)
 }
 ```
+— *end example*]
 For a given inline function defined in different translation units, the
 accumulated sets of default arguments at the end of the translation
 units shall be the same; see  [[basic.def.odr]]. If a friend declaration
 specifies a default argument expression, that declaration shall be a
 definition and shall be the only declaration of the function or function
 the copy-initialization semantics ([[dcl.init]]). The names in the
 default argument are bound, and the semantic constraints are checked, at
 the point where the default argument appears. Name lookup and checking
 of semantic constraints for default arguments in function templates and
 in member functions of class templates are performed as described in
+[[temp.inst]].
+[*Example 3*:
+In the following code, `g` will be called with the value `f(2)`:
 ``` cpp
 int a = 1;
 int f(int);
 int g(int x = f(a));            // default argument: f(::a)
   g();                          // g(f(::a))
   }
 }
 ```
+— *end example*]
+[*Note 1*: In member function declarations, names in default arguments
+are looked up as described in  [[basic.lookup.unqual]]. Access checking
+applies to names in default arguments as described in Clause
+[[class.access]]. — *end note*]
 Except for member functions of class templates, the default arguments in
 a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
 constructor, or copy or move assignment operator ([[class.copy]]) is so
 declared. Default arguments for a member function of a class template
 shall be specified on the initial declaration of the member function
 within the class template.
+[*Example 4*:
 ``` cpp
 class C {
   void f(int i = 3);
   void g(int i, int j = 99);
 };
+void C::f(int i = 3) {}         // error: default argument already specified in class scope
+void C::g(int i = 88, int j) {} // in this translation unit, C::g can be called with no argument
 ```
+— *end example*]
+A local variable shall not appear as a potentially-evaluated expression
+in a default argument.
+[*Example 5*:
 ``` cpp
 void f() {
   int i;
   extern void g(int x = i);         // error
+  extern void h(int x = sizeof(i)); // OK
   // ...
 }
 ```
+— *end example*]
+[*Note 2*:
+The keyword `this` may not appear in a default argument of a member
+function; see  [[expr.prim.this]].
+[*Example 6*:
 ``` cpp
 class A {
   void f(A* p = this) { }           // error
 };
 ```
+— *end example*]
+— *end note*]
 A default argument is evaluated each time the function is called with no
+argument for the corresponding parameter. A parameter shall not appear
+as a potentially-evaluated expression in a default argument. Parameters
+of a function declared before a default argument are in scope and can
+hide namespace and class member names.
+[*Example 7*:
 ``` cpp
 int a;
+int f(int a, int b = a);            // error: parameter a used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter I found
+int h(int a, int b = sizeof(a));    // OK, unevaluated operand
 ```
+— *end example*]
+A non-static member shall not appear in a default argument unless it
+appears as the *id-expression* of a class member access expression (
+[[expr.ref]]) or unless it is used to form a pointer to member (
+[[expr.unary.op]]).
+[*Example 8*:
+The declaration of `X::mem1()` in the following example is ill-formed
+because no object is supplied for the non-static member `X::a` used as
+an initializer.
 ``` cpp
 int b;
 class X {
   int a;
+  int mem1(int i = a); // error: non-static member a used as default argument
   int mem2(int i = b);              // OK;  use X::b
   static int b;
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
 is needed to access the static member `X::b`. Classes, objects, and
+members are described in Clause  [[class]].
+— *end example*]
+A default argument is not part of the type of a function.
+[*Example 9*:
 ``` cpp
 int f(int = 0);
 void h() {
 int (*p1)(int) = &f;
 int (*p2)() = &f;                   // error: type mismatch
 ```
+— *end example*]
 When a declaration of a function is introduced by way of a
 *using-declaration* ([[namespace.udecl]]), any default argument
 information associated with the declaration is made known as well. If
 the function is redeclared thereafter in the namespace with additional
 default arguments, the additional arguments are also known at any point
 in the declaration of the virtual function determined by the static type
 of the pointer or reference denoting the object. An overriding function
 in a derived class does not acquire default arguments from the function
 it overrides.
+[*Example 10*:
 ``` cpp
 struct A {
   virtual void f(int a = 7);
 };
 struct B : public A {
   pa->f();          // OK, calls pa->B::f(7)
   pb->f();          // error: wrong number of arguments for B::f()
 }
 ```
+— *end example*]
 ## Function definitions <a id="dcl.fct.def">[[dcl.fct.def]]</a>
 ### In general <a id="dcl.fct.def.general">[[dcl.fct.def.general]]</a>
 Function definitions have the form
 as a reference to the non-terminal *function-body*. The optional
 *attribute-specifier-seq* in a *function-definition* appertains to the
 function. A *virt-specifier-seq* can be part of a *function-definition*
 only if it is a *member-declaration* ([[class.mem]]).
+In a *function-definition*, either `void` *declarator* `;` or
+*declarator* `;` shall be a well-formed function declaration as
+described in  [[dcl.fct]]. A function shall be defined only in namespace
+or class scope.
+[*Example 1*:
+A simple example of a complete function definition is
 ``` cpp
 int max(int a, int b, int c) {
   int m = (a > b) ? a : b;
   return (m > c) ? m : c;
 ```
 Here `int` is the *decl-specifier-seq*; `max(int` `a,` `int` `b,` `int`
 `c)` is the *declarator*; `{ /* ... */ }` is the *function-body*.
+— *end example*]
 A *ctor-initializer* is used only in a constructor; see  [[class.ctor]]
 and  [[class.init]].
+[*Note 1*: A *cv-qualifier-seq* affects the type of `this` in the body
+of a member function; see  [[dcl.ref]]. — *end note*]
+[*Note 2*:
 Unused parameters need not be named. For example,
 ``` cpp
 void print(int a, int) {
   std::printf("a = %d\n",a);
 }
 ```
+— *end note*]
 In the *function-body*, a *function-local predefined variable* denotes a
 block-scope object of static storage duration that is implicitly defined
 (see  [[basic.scope.block]]).
 The function-local predefined variable `__func__` is defined as if a
 static const char __func__[] = "function-name";
 ```
 had been provided, where *function-name* is an *implementation-defined*
 string. It is unspecified whether such a variable has an address
+distinct from that of any other object in the program.[^11]
+[*Example 2*:
 ``` cpp
 struct S {
   S() : s(__func__) { }             // OK
   const char* s;
 };
 void f(const char* s = __func__);   // error: __func__ is undeclared
 ```
+— *end example*]
 ### Explicitly-defaulted functions <a id="dcl.fct.def.default">[[dcl.fct.def.default]]</a>
 A function definition of the form:
 ``` bnf
   copy assignment operator, the parameter type may be “reference to
   non-const `T`”, where `T` is the name of the member function’s class)
   as if it had been implicitly declared, and
 - not have default arguments.
+An explicitly-defaulted function that is not defined as deleted may be
+declared `constexpr` only if it would have been implicitly declared as
+`constexpr`. If a function is explicitly defaulted on its first
+declaration, it is implicitly considered to be `constexpr` if the
+implicit declaration would be.
+If a function that is explicitly defaulted is declared with a
+*noexcept-specifier* that does not produce the same exception
+specification as the implicit declaration ([[except.spec]]), then
 - if the function is explicitly defaulted on its first declaration, it
   is defined as deleted;
 - otherwise, the program is ill-formed.
+[*Example 1*:
 ``` cpp
 struct S {
   constexpr S() = default;              // ill-formed: implicit S() is not constexpr
   S(int a = 0) = default;               // ill-formed: default argument
   void operator=(const S&) = default;   // ill-formed: non-matching return type
+  ~S() noexcept(false) = default; // deleted: exception specification does not match
 private:
   int i;
   S(S&);                                // OK: private copy constructor
 };
 S::S(S&) = default;                     // OK: defines copy constructor
 ```
+— *end example*]
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
 provide implicit definitions for them ([[class.ctor]] [[class.dtor]],
 [[class.copy]]), which might mean defining them as deleted. A function
 is *user-provided* if it is user-declared and not explicitly defaulted
 or deleted on its first declaration. A user-provided
 explicitly-defaulted function (i.e., explicitly defaulted after its
 first declaration) is defined at the point where it is explicitly
 defaulted; if such a function is implicitly defined as deleted, the
+program is ill-formed.
+[*Note 1*: Declaring a function as defaulted after its first
 declaration can provide efficient execution and concise definition while
+enabling a stable binary interface to an evolving code
+base. — *end note*]
+[*Example 2*:
 ``` cpp
 struct trivial {
   trivial() = default;
   trivial(const trivial&) = default;
   nontrivial1();
 };
 nontrivial1::nontrivial1() = default;   // not first declaration
 ```
+— *end example*]
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
 A function definition of the form:
 ``` bnf
 is called a *deleted definition*. A function with a deleted definition
 is also called a *deleted function*.
 A program that refers to a deleted function implicitly or explicitly,
+other than to declare it, is ill-formed.
+[*Note 1*: This includes calling the function implicitly or explicitly
+and forming a pointer or pointer-to-member to the function. It applies
+even for references in expressions that are not potentially-evaluated.
+If a function is overloaded, it is referenced only if the function is
+selected by overload resolution. The implicit odr-use (
+[[basic.def.odr]]) of a virtual function does not, by itself, constitute
+a reference. — *end note*]
+[*Example 1*:
+One can enforce non-default-initialization and non-integral
 initialization with
 ``` cpp
 struct onlydouble {
   onlydouble() = delete;                // OK, but redundant
   onlydouble(std::intmax_t) = delete;
   onlydouble(double);
 };
 ```
+— *end example*]
+[*Example 2*:
+One can prevent use of a class in certain *new-expression*s by using
 deleted definitions of a user-declared `operator new` for that class.
 ``` cpp
 struct sometype {
   void* operator new(std::size_t) = delete;
 };
 sometype* p = new sometype;     // error, deleted class operator new
 sometype* q = new sometype[3];  // error, deleted class operator new[]
 ```
+— *end example*]
+[*Example 3*:
 One can make a class uncopyable, i.e. move-only, by using deleted
 definitions of the copy constructor and copy assignment operator, and
 then providing defaulted definitions of the move constructor and move
 assignment operator.
 };
 moveonly* p;
 moveonly q(*p);                 // error, deleted copy constructor
 ```
+— *end example*]
+A deleted function is implicitly an inline function ([[dcl.inline]]).
+[*Note 2*: The one-definition rule ([[basic.def.odr]]) applies to
+deleted definitions. — *end note*]
+A deleted definition of a function shall be the first declaration of the
+function or, for an explicit specialization of a function template, the
+first declaration of that specialization. An implicitly declared
+allocation or deallocation function ([[basic.stc.dynamic]]) shall not
+be defined as deleted.
+[*Example 4*:
 ``` cpp
 struct sometype {
   sometype();
 };
 sometype::sometype() = delete;  // ill-formed; not first declaration
 ```
+— *end example*]
+## Structured binding declarations <a id="dcl.struct.bind">[[dcl.struct.bind]]</a>
+A structured binding declaration introduces the *identifier*s `v`₀,
+`v`₁, `v`₂, ... of the *identifier-list* as names (
+[[basic.scope.declarative]]), called *structured binding*s. Let cv
+denote the *cv-qualifier*s in the *decl-specifier-seq*. First, a
+variable with a unique name `e` is introduced. If the
+*assignment-expression* in the *initializer* has array type `A` and no
+*ref-qualifier* is present, `e` has type cv `A` and each element is
+copy-initialized or direct-initialized from the corresponding element of
+the *assignment-expression* as specified by the form of the
+*initializer*. Otherwise, `e` is defined as-if by
+``` bnf
+attribute-specifier-seqₒₚₜ decl-specifier-seq ref-qualifierₒₚₜ 'e' initializer ';'
+```
+where the declaration is never interpreted as a function declaration and
+the parts of the declaration other than the *declarator-id* are taken
+from the corresponding structured binding declaration. The type of the
+*id-expression* `e` is called `E`.
+[*Note 1*: `E` is never a reference type (Clause
+[[expr]]). — *end note*]
+If `E` is an array type with element type `T`, the number of elements in
+the *identifier-list* shall be equal to the number of elements of `E`.
+Each `v`ᵢ is the name of an lvalue that refers to the element i of the
+array and whose type is `T`; the referenced type is `T`.
+[*Note 2*: The top-level cv-qualifiers of `T` are cv. — *end note*]
+[*Example 1*:
+``` cpp
+  auto f() -> int(&)[2];
+  auto [ x, y ] = f();          // x and y refer to elements in a copy of the array return value
+  auto& [ xr, yr ] = f();       // xr and yr refer to elements in the array referred to by f's return value
+```
+— *end example*]
+Otherwise, if the *qualified-id* `std::tuple_size<E>` names a complete
+type, the expression `std::tuple_size<E>::value` shall be a well-formed
+integral constant expression and the number of elements in the
+*identifier-list* shall be equal to the value of that expression. The
+*unqualified-id* `get` is looked up in the scope of `E` by class member
+access lookup ([[basic.lookup.classref]]), and if that finds at least
+one declaration, the initializer is `e.get<i>()`. Otherwise, the
+initializer is `get<i>(e)`, where `get` is looked up in the associated
+namespaces ([[basic.lookup.argdep]]). In either case, `get<i>` is
+interpreted as a *template-id*.
+[*Note 3*: Ordinary unqualified lookup ([[basic.lookup.unqual]]) is
+not performed. — *end note*]
+In either case, `e` is an lvalue if the type of the entity `e` is an
+lvalue reference and an xvalue otherwise. Given the type `Tᵢ` designated
+by `std::tuple_element<i, E>::type`, each `v`ᵢ is a variable of type
+“reference to `Tᵢ`” initialized with the initializer, where the
+reference is an lvalue reference if the initializer is an lvalue and an
+rvalue reference otherwise; the referenced type is `Tᵢ`.
+Otherwise, all of `E`’s non-static data members shall be public direct
+members of `E` or of the same unambiguous public base class of `E`, `E`
+shall not have an anonymous union member, and the number of elements in
+the *identifier-list* shall be equal to the number of non-static data
+members of `E`. Designating the non-static data members of `E` as `m`₀,
+`m`₁, `m`₂, ... (in declaration order), each `v`ᵢ is the name of an
+lvalue that refers to the member `m`ᵢ of `e` and whose type is cv `Tᵢ`,
+where `Tᵢ` is the declared type of that member; the referenced type is
+cv `Tᵢ`. The lvalue is a bit-field if that member is a bit-field.
+[*Example 2*:
+``` cpp
+struct S { int x1 : 2; volatile double y1; };
+S f();
+const auto [ x, y ] = f();
+```
+The type of the *id-expression* `x` is “`const int`”, the type of the
+*id-expression* `y` is “`const volatile double`”.
+— *end example*]
 ## 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 ')'
 braced-init-list:
     '{' initializer-list ','ₒₚₜ '}'
     '{' '}'
 ```
+``` bnf
+expr-or-braced-init-list:
+    expression
+    braced-init-list
+```
 Except for objects declared with the `constexpr` specifier, for which
 see  [[dcl.constexpr]], an *initializer* in the definition of a variable
 can consist of arbitrary expressions involving literals and previously
 declared variables and functions, regardless of the variable’s storage
 duration.
+[*Example 1*:
 ``` cpp
 int f(int);
 int a = 2;
 int b = f(a);
 int c(b);
 ```
+— *end example*]
+[*Note 1*: Default arguments are more restricted; see
+[[dcl.fct.default]]. — *end note*]
+[*Note 2*: The order of initialization of variables with static storage
+duration is described in  [[basic.start]] and
+[[stmt.dcl]]. — *end note*]
 A declaration of a block-scope variable with external or internal
 linkage that has an *initializer* is ill-formed.
 To *zero-initialize* an object or reference of type `T` means:
 - if `T` is a scalar type ([[basic.types]]), the object is initialized
   to the value obtained by converting the integer literal `0` (zero) to
+  `T`;[^12]
 - if `T` is a (possibly cv-qualified) non-union class type, each
+  non-static data member, each non-virtual base class subobject, and, if
+ the object is not a base class subobject, each virtual base class
+  subobject is zero-initialized and padding is initialized to zero bits;
 - if `T` is a (possibly cv-qualified) union type, the object’s first
   non-static named data member is zero-initialized and padding is
   initialized to zero bits;
 - if `T` is an array type, each element is zero-initialized;
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
+- If `T` is a (possibly cv-qualified) class type (Clause  [[class]]),
+ constructors are considered. The applicable constructors are
+ enumerated ([[over.match.ctor]]), and the best one for the
+ *initializer* `()` is chosen through overload resolution (
+ [[over.match]]). The constructor thus selected is called, with an
+ empty argument list, to initialize the object.
+- If `T` is an array type, each element is default-initialized.
+- Otherwise, no initialization is performed.
+A class type `T` is *const-default-constructible* if
+default-initialization of `T` would invoke a user-provided constructor
+of `T` (not inherited from a base class) or if
+- each direct non-variant non-static data member `M` of `T` has a
+  default member initializer or, if `M` is of class type `X` (or array
+  thereof), `X` is const-default-constructible,
+- if `T` is a union with at least one non-static data member, exactly
+  one variant member has a default member initializer,
+- if `T` is not a union, for each anonymous union member with at least
+  one non-static data member (if any), exactly one non-static data
+  member has a default member initializer, and
+- each potentially constructed base class of `T` is
+  const-default-constructible.
+If a program calls for the default-initialization of an object of a
+const-qualified type `T`, `T` shall be a const-default-constructible
+class type or array thereof.
 To *value-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]])
   with either no default constructor ([[class.ctor]]) or a default
   and if `T` has a non-trivial default constructor, the object is
   default-initialized;
 - if `T` is an array type, then each element is value-initialized;
 - otherwise, the object is zero-initialized.
 A program that calls for default-initialization or value-initialization
 of an entity of reference type is ill-formed.
+[*Note 3*: Every object of static storage duration is zero-initialized
+at program startup before any other initialization takes place. In some
+cases, additional initialization is done later. — *end note*]
 An object whose initializer is an empty set of parentheses, i.e., `()`,
 shall be value-initialized.
+[*Note 4*:
 Since `()` is not permitted by the syntax for *initializer*,
 ``` cpp
 X a();
 ```
 is not the declaration of an object of class `X`, but the declaration of
 a function taking no argument and returning an `X`. The form `()` is
 permitted in certain other initialization contexts ([[expr.new]],
 [[expr.type.conv]], [[class.base.init]]).
+— *end note*]
 If no initializer is specified for an object, the object is
 default-initialized. When storage for an object with automatic or
 dynamic storage duration is obtained, the object has an *indeterminate
 value*, and if no initialization is performed for the object, that
 object retains an indeterminate value until that value is replaced (
+[[expr.ass]]).
+[*Note 5*: Objects with static or thread storage duration are
+zero-initialized, see  [[basic.start.static]]. — *end note*]
+If an indeterminate value is produced by an evaluation, the behavior is
+undefined except in the following cases:
 - If an indeterminate value of unsigned narrow character type (
+  [[basic.fundamental]]) or `std::byte` type ([[cstddef.syn]]) is
+  produced by the evaluation of:
   - the second or third operand of a conditional expression (
     [[expr.cond]]),
   - the right operand of a comma expression ([[expr.comma]]),
+  - the operand of a cast or conversion ([[conv.integral]],
+    [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]]) to an
+ unsigned narrow character type or `std::byte` type (
+    [[cstddef.syn]]), or
   - a discarded-value expression (Clause  [[expr]]),
   then the result of the operation is an indeterminate value.
+- If an indeterminate value of unsigned narrow character type or
+ `std::byte` type is produced by the evaluation of the right operand of
+ a simple assignment operator ([[expr.ass]]) whose first operand is an
+ lvalue of unsigned narrow character type or `std::byte` type, an
+ indeterminate value replaces the value of the object referred to by
+  the left operand.
 - If an indeterminate value of unsigned narrow character type is
   produced by the evaluation of the initialization expression when
   initializing an object of unsigned narrow character type, that object
   is initialized to an indeterminate value.
+- If an indeterminate value of unsigned narrow character type or
+  `std::byte` type is produced by the evaluation of the initialization
+  expression when initializing an object of `std::byte` type, that
+  object is initialized to an indeterminate value.
+[*Example 2*:
 ``` cpp
   int f(bool b) {
     unsigned char c;
     unsigned char d = c;        // OK, d has an indeterminate value
     int e = d;                  // undefined behavior
     return b ? d : 0;           // undefined behavior if b is true
   }
 ```
+— *end example*]
 An initializer for a static member is in the scope of the member’s
 class.
+[*Example 3*:
 ``` cpp
 int a;
 struct X {
   static int a;
 int X::a = 1;
 int X::b = a;                   // X::b = X::a
 ```
+— *end example*]
+If the entity being initialized does not have class type, the
+*expression-list* in a parenthesized initializer shall be a single
+expression.
+The initialization that occurs in the `=` form of a
+*brace-or-equal-initializer* or *condition* ([[stmt.select]]), as well
+as in argument passing, function return, throwing an exception (
 [[except.throw]]), handling an exception ([[except.handle]]), and
+aggregate member initialization ([[dcl.init.aggr]]), is called
+*copy-initialization*.
+[*Note 6*: Copy-initialization may invoke a move (
+[[class.copy]]). — *end note*]
 The initialization that occurs in the forms
 ``` cpp
 T x(a);
 T x{a};
 ```
+as well as in `new` expressions ([[expr.new]]), `static_cast`
+expressions ([[expr.static.cast]]), functional notation type
+conversions ([[expr.type.conv]]), *mem-initializer*s (
+[[class.base.init]]), and the *braced-init-list* form of a *condition*
+is called *direct-initialization*.
 The semantics of initializers are as follows. The *destination type* is
 the type of the object or reference being initialized and the *source
 type* is the type of the initializer expression. If the initializer is
 not a single (possibly parenthesized) expression, the source type is not
 defined.
+- If the initializer is a (non-parenthesized) *braced-init-list* or is
+ `=` *braced-init-list*, the object or reference is list-initialized (
+  [[dcl.init.list]]).
 - If the destination type is a reference type, see  [[dcl.init.ref]].
 - If the destination type is an array of characters, an array of
   `char16_t`, an array of `char32_t`, or an array of `wchar_t`, and the
   initializer is a string literal, see  [[dcl.init.string]].
 - If the initializer is `()`, the object is value-initialized.
 - Otherwise, if the destination type is an array, the program is
   ill-formed.
 - If the destination type is a (possibly cv-qualified) class type:
+  - If the initializer expression is a prvalue and the cv-unqualified
+ version of the source type is the same class as the class of the
+ destination, the initializer expression is used to initialize the
+    destination object. \[*Example 4*: `T x = T(T(T()));` calls the `T`
+    default constructor to initialize `x`. — *end example*]
+  - Otherwise, if the initialization is direct-initialization, or if it
+    is copy-initialization where the cv-unqualified version of the
+    source type is the same class as, or a derived class of, the class
+    of the destination, constructors are considered. The applicable
     constructors are enumerated ([[over.match.ctor]]), and the best one
     is chosen through overload resolution ([[over.match]]). The
     constructor so selected is called to initialize the object, with the
     initializer expression or *expression-list* as its argument(s). If
     no constructor applies, or the overload resolution is ambiguous, the
     to a derived class thereof are enumerated as described in
     [[over.match.copy]], and the best one is chosen through overload
     resolution ([[over.match]]). If the conversion cannot be done or is
     ambiguous, the initialization is ill-formed. The function selected
     is called with the initializer expression as its argument; if the
+    function is a constructor, the call is a prvalue of the
+    cv-unqualified version of the destination type whose result object
+ is initialized by the constructor. The call is used to
+    direct-initialize, according to the rules above, the object that is
+    the destination of the copy-initialization.
 - Otherwise, if the source type is a (possibly cv-qualified) class type,
   conversion functions are considered. The applicable conversion
   functions are enumerated ([[over.match.conv]]), and the best one is
   chosen through overload resolution ([[over.match]]). The user-defined
   conversion so selected is called to convert the initializer expression
 - Otherwise, the initial value of the object being initialized is the
   (possibly converted) value of the initializer expression. Standard
   conversions (Clause  [[conv]]) will be used, if necessary, to convert
   the initializer expression to the cv-unqualified version of the
   destination type; no user-defined conversions are considered. If the
+  conversion cannot be done, the initialization is ill-formed. When
+ initializing a bit-field with a value that it cannot represent, the
+ resulting value of the bit-field is *implementation-defined*.
+  \[*Note 7*:
+  An expression of type “*cv1* `T`” can initialize an object of type
+  “*cv2* `T`” independently of the cv-qualifiers *cv1* and *cv2*.
   ``` cpp
   int a;
   const int b = a;
   int c = b;
   ```
+  — *end note*]
 An *initializer-clause* followed by an ellipsis is a pack expansion (
 [[temp.variadic]]).
+If the initializer is a parenthesized *expression-list*, the expressions
+are evaluated in the order specified for function calls (
+[[expr.call]]).
+An object whose initialization has completed is deemed to be
+constructed, even if no constructor of the object’s class is invoked for
+the initialization.
+[*Note 8*: Such an object might have been value-initialized or
+initialized by aggregate initialization ([[dcl.init.aggr]]) or by an
+inherited constructor ([[class.inhctor.init]]). — *end note*]
+A declaration that specifies the initialization of a variable, whether
+from an explicit initializer or by default-initialization, is called the
+*initializing declaration* of that variable.
+[*Note 9*: In most cases this is the defining declaration (
+[[basic.def]]) of the variable, but the initializing declaration of a
+non-inline static data member ([[class.static.data]]) might be the
+declaration within the class definition and not the definition at
+namespace scope. — *end note*]
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
+An *aggregate* is an array or a class (Clause  [[class]]) with
+- no user-provided, `explicit`, or inherited constructors (
+ [[class.ctor]]),
+- no private or protected non-static data members (Clause
+  [[class.access]]),
+- no virtual functions ([[class.virtual]]), and
+- no virtual, private, or protected base classes ([[class.mi]]).
+[*Note 1*: Aggregate initialization does not allow accessing protected
+and private base class’ members or constructors. — *end note*]
+The *elements* of an aggregate are:
+- for an array, the array elements in increasing subscript order, or
+- for a class, the direct base classes in declaration order, followed by
+  the direct non-static data members ([[class.mem]]) that are not
+  members of an anonymous union, in declaration order.
+When an aggregate is initialized by an initializer list as specified in
+[[dcl.init.list]], the elements of the initializer list are taken as
+initializers for the elements of the aggregate, in order. Each element
+is copy-initialized from the corresponding *initializer-clause*. If the
+*initializer-clause* is an expression and a narrowing conversion (
+[[dcl.init.list]]) is required to convert the expression, the program is
+ill-formed.
+[*Note 2*: If an *initializer-clause* is itself an initializer list,
+the element is list-initialized, which will result in a recursive
+application of the rules in this section if the element is an
+aggregate. — *end note*]
+[*Example 1*:
 ``` cpp
 struct A {
   int x;
   struct B {
 } a = { 1, { 2, 3 } };
 ```
 initializes `a.x` with 1, `a.b.i` with 2, `a.b.j` with 3.
+``` cpp
+struct base1 { int b1, b2 = 42; };
+struct base2 {
+  base2() {
+    b3 = 42;
+  }
+  int b3;
+};
+struct derived : base1, base2 {
+  int d;
+};
+derived d1{{1, 2}, {}, 4};
+derived d2{{}, {}, 4};
+```
+initializes `d1.b1` with 1, `d1.b2` with 2, `d1.b3` with 42, `d1.d` with
+4, and `d2.b1` with 0, `d2.b2` with 42, `d2.b3` with 42, `d2.d` with 4.
+— *end example*]
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in  [[dcl.init]].
+An array of unknown bound initialized with a brace-enclosed
 *initializer-list* containing `n` *initializer-clause*s, where `n` shall
+be greater than zero, is defined as having `n` elements (
 [[dcl.array]]).
+[*Example 2*:
 ``` cpp
 int x[] = { 1, 3, 5 };
 ```
 declares and initializes `x` as a one-dimensional array that has three
 elements since no size was specified and there are three initializers.
+— *end example*]
 An empty initializer list `{}` shall not be used as the
+*initializer-clause* for an array of unknown bound.[^13]
+[*Note 3*:
+A default member initializer does not determine the bound for a member
+array of unknown bound. Since the default member initializer is ignored
+if a suitable *mem-initializer* is present ([[class.base.init]]), the
+default member initializer is not considered to initialize the array of
+unknown bound.
+[*Example 3*:
+``` cpp
+struct S {
+  int y[] = { 0 };          // error: non-static data member of incomplete type
+};
+```
+— *end example*]
+— *end note*]
+[*Note 4*:
+Static data members and unnamed bit-fields are not considered elements
+of the aggregate.
+[*Example 4*:
 ``` cpp
 struct A {
   int i;
   static int s;
 } a = { 1, 2, 3 };
 ```
 Here, the second initializer 2 initializes `a.j` and not the static data
 member `A::s`, and the third initializer 3 initializes `a.k` and not the
+unnamed bit-field before it.
+— *end example*]
+— *end note*]
 An *initializer-list* is ill-formed if the number of
+*initializer-clause*s exceeds the number of elements to initialize.
+[*Example 5*:
 ``` cpp
 char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
 ```
 is ill-formed.
+— *end example*]
 If there are fewer *initializer-clause*s in the list than there are
+elements in a non-union aggregate, then each element not explicitly
+initialized is initialized as follows:
+- If the element has a default member initializer ([[class.mem]]), the
+  element is initialized from that initializer.
+- Otherwise, if the element is not a reference, the element is
+  copy-initialized from an empty initializer list ([[dcl.init.list]]).
+- Otherwise, the program is ill-formed.
+If the aggregate is a union and the initializer list is empty, then
+- if any variant member has a default member initializer, that member is
+  initialized from its default member initializer;
+- otherwise, the first member of the union (if any) is copy-initialized
+  from an empty initializer list.
+[*Example 6*:
 ``` cpp
 struct S { int a; const char* b; int c; int d = b[a]; };
 S ss = { 1, "asdf" };
 ```
 X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
 ```
 `a` and `b` have the same value
+— *end example*]
+If a reference member is initialized from its default member initializer
+and a potentially-evaluated subexpression thereof is an aggregate
+initialization that would use that default member initializer, the
+program is ill-formed.
+[*Example 7*:
+``` cpp
+  struct A;
+  extern A a;
+  struct A {
+    const A& a1 { A{a,a} };     // OK
+    const A& a2 { A{} };        // error
+  };
+  A a{a,a};                     // OK
+```
+— *end example*]
+If an aggregate class `C` contains a subaggregate element `e` with no
+elements, the *initializer-clause* for `e` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
+*initializer-clause*s for all elements of `C` following `e` are also
 omitted.
+[*Example 8*:
 ``` cpp
 struct S { } s;
 struct A {
   S s1;
   int i1;
   s,                // Required initialization
   0
 };                  // Initialization not required for A::s3 because A::i3 is also not initialized
 ```
+— *end example*]
 When initializing a multi-dimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
 varying the fastest ([[dcl.array]]).
+[*Example 9*:
 ``` cpp
 int x[2][2] = { 3, 1, 4, 2 };
 ```
 initializes `x[0][0]` to `3`, `x[0][1]` to `1`, `x[1][0]` to `4`, and
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
+— *end example*]
 Braces can be elided in an *initializer-list* as follows. If the
 *initializer-list* begins with a left brace, then the succeeding
+comma-separated list of *initializer-clause*s initializes the elements
+of a subaggregate; it is erroneous for there to be more
+*initializer-clause*s than elements. If, however, the *initializer-list*
 for a subaggregate does not begin with a left brace, then only enough
+*initializer-clause*s from the list are taken to initialize the elements
 of the subaggregate; any remaining *initializer-clause*s are left to
+initialize the next element of the aggregate of which the current
+subaggregate is an element.
+[*Example 10*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
 The initializer for `y` begins with a left brace, but the one for `y[0]`
 does not, therefore three elements from the list are used. Likewise the
 next three are taken successively for `y[1]` and `y[2]`.
+— *end example*]
 All implicit type conversions (Clause  [[conv]]) are considered when
+initializing the element with an *assignment-expression*. If the
+*assignment-expression* can initialize an element, the element is
+initialized. Otherwise, if the element is itself a subaggregate, brace
 elision is assumed and the *assignment-expression* is considered for the
+initialization of the first element of the subaggregate.
+[*Note 5*: As specified above, brace elision cannot apply to
+subaggregates with no elements; an *initializer-clause* for the entire
+subobject is required. — *end note*]
+[*Example 11*:
 ``` cpp
 struct A {
   int i;
   operator int();
 Braces are elided around the *initializer-clause* for `b.a1.i`. `b.a1.i`
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
+— *end example*]
+[*Note 6*: An aggregate array or an aggregate class may contain
+elements of a class type with a user-provided constructor (
+[[class.ctor]]). Initialization of these aggregate objects is described
+in  [[class.expl.init]]. — *end note*]
+[*Note 7*: Whether the initialization of aggregates with static storage
+duration is static or dynamic is specified in  [[basic.start.static]],
+[[basic.start.dynamic]], and  [[stmt.dcl]]. — *end note*]
 When a union is initialized with a brace-enclosed initializer, the
 braces shall only contain an *initializer-clause* for the first
 non-static data member of the union.
+[*Example 12*:
 ``` cpp
 union u { int a; const char* b; };
 u a = { 1 };
 u b = a;
 u c = 1;                        // error
 u d = { 0, "asdf" };            // error
 u e = { "asdf" };               // error
 ```
+— *end example*]
+[*Note 8*: As described above, the braces around the
+*initializer-clause* for a union member can be omitted if the union is a
+member of another aggregate. — *end note*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 An array of narrow character type ([[basic.fundamental]]), `char16_t`
 array, `char32_t` array, or `wchar_t` array can be initialized by a
 literal, or wide string literal, respectively, or by an
 appropriately-typed string literal enclosed in braces ([[lex.string]]).
 Successive characters of the value of the string literal initialize the
 elements of the array.
+[*Example 1*:
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 ```
 shows a character array whose members are initialized with a
 *string-literal*. Note that because `'\n'` is a single character and
 because a trailing `'\0'` is appended, `sizeof(msg)` is `25`.
+— *end example*]
 There shall not be more initializers than there are array elements.
+[*Example 2*:
 ``` cpp
 char cv[4] = "asdf";            // error
 ```
 is ill-formed since there is no space for the implied trailing `'\0'`.
+— *end example*]
 If there are fewer initializers than there are array elements, each
 element not explicitly initialized shall be zero-initialized (
 [[dcl.init]]).
 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
+A variable whose declared type is “reference to type `T`” ([[dcl.ref]])
+shall be initialized.
+[*Example 1*:
 ``` cpp
+int g(int) noexcept;
 void f() {
   int i;
   int& r = i;                   // r refers to i
   r = 1;                        // the value of i becomes 1
   int* p = &r;                  // p points to i
   int (&ra)[3] = a;             // ra refers to the array a
   ra[1] = i;                    // modifies a[1]
 }
 ```
+— *end example*]
 A reference cannot be changed to refer to another object after
+initialization.
+[*Note 1*: Assignment to a reference assigns to the object referred to
+by the reference ([[expr.ass]]). — *end note*]
+Argument passing ([[expr.call]]) and function value return (
+[[stmt.return]]) are initializations.
 The initializer can be omitted for a reference only in a parameter
 declaration ([[dcl.fct]]), in the declaration of a function return
 type, in the declaration of a class member within its class definition (
 [[class.mem]]), and where the `extern` specifier is explicitly used.
+[*Example 2*:
 ``` cpp
 int& r1;                        // error: initializer missing
 extern int& r2;                 // OK
 ```
+— *end example*]
+Given types “*cv1* `T1`” and “*cv2* `T2`”, “*cv1* `T1`” is
+*reference-related* to “*cv2* `T2`” if `T1` is the same type as `T2`, or
+`T1` is a base class of `T2`. “*cv1* `T1`” is *reference-compatible*
+with “*cv2* `T2`” if
+- `T1` is reference-related to `T2`, or
+- `T2` is “`noexcept` function” and `T1` is “function”, where the
+  function types are otherwise the same,
+and *cv1* is the same cv-qualification as, or greater cv-qualification
+than, *cv2*. In all cases where the reference-related or
+reference-compatible relationship of two types is used to establish the
+validity of a reference binding, and `T1` is a base class of `T2`, a
+program that necessitates such a binding is ill-formed if `T1` is an
+inaccessible (Clause  [[class.access]]) or ambiguous (
+[[class.member.lookup]]) base class of `T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
+  - is an lvalue (but is not a bit-field), and “*cv1* `T1`” is
+    reference-compatible with “*cv2* `T2`”, or
   - has a class type (i.e., `T2` is a class type), where `T1` is not
     reference-related to `T2`, and can be converted to an lvalue of type
+    “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
+ `T3`”[^14] (this conversion is selected by enumerating the
+ applicable conversion functions ([[over.match.ref]]) and choosing
+ the best one through overload resolution ([[over.match]])),
   then the reference is bound to the initializer expression lvalue in
   the first case and to the lvalue result of the conversion in the
   second case (or, in either case, to the appropriate base class
+  subobject of the object).
+  \[*Note 2*: The usual lvalue-to-rvalue ([[conv.lval]]),
   array-to-pointer ([[conv.array]]), and function-to-pointer (
   [[conv.func]]) standard conversions are not needed, and therefore are
+  suppressed, when such direct bindings to lvalues are
+  done. — *end note*]
+  \[*Example 3*:
   ``` cpp
   double d = 2.0;
   double& rd = d;                 // rd refers to d
   const double& rcd = d;          // rcd refers to d
   struct B : A { operator int&(); } b;
   A& ra = b;                      // ra refers to A subobject in b
   const A& rca = b;               // rca refers to A subobject in b
   int& ir = B();                  // ir refers to the result of B::operator int&
   ```
+  — *end example*]
 - Otherwise, the reference shall be an lvalue reference to a
   non-volatile const type (i.e., *cv1* shall be `const`), or the
   reference shall be an rvalue reference.
+  \[*Example 4*:
   ``` cpp
   double& rd2 = 2.0;              // error: not an lvalue and reference not const
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
+  — *end example*]
   - If the initializer expression
+    - is an rvalue (but not a bit-field) or function lvalue and “*cv1*
+      `T1`” is reference-compatible with “*cv2* `T2`”, or
     - has a class type (i.e., `T2` is a class type), where `T1` is not
+      reference-related to `T2`, and can be converted to an rvalue or
+      function lvalue of type “*cv3* `T3`”, where “*cv1* `T1`” is
+      reference-compatible with “*cv3* `T3`” (see  [[over.match.ref]]),
+    then the value of the initializer expression in the first case and
+    the result of the conversion in the second case is called the
+ converted initializer. If the converted initializer is a prvalue,
+ its type `T4` is adjusted to type “*cv1* `T4`” ([[conv.qual]]) and
+    the temporary materialization conversion ([[conv.rval]]) is
+ applied. In any case, the reference is bound to the resulting
+ glvalue (or to an appropriate base class subobject).
+    \[*Example 5*:
     ``` cpp
     struct A { };
     struct B : A { } b;
     extern B f();
     const A& rca2 = f();                // bound to the A subobject of the B rvalue.
     } x;
     const A& r = x;                     // bound to the A subobject of the result of the conversion
     int i2 = 42;
     int&& rri = static_cast<int&&>(i2); // bound directly to i2
     B&& rrb = x;                        // bound directly to the result of operator B
     ```
+    — *end example*]
   - Otherwise:
+    - If `T1` or `T2` is a class type and `T1` is not reference-related
+ to `T2`, user-defined conversions are considered using the rules
+ for copy-initialization of an object of type “*cv1* `T1`” by
+ user-defined conversion ([[dcl.init]], [[over.match.copy]],
+      [[over.match.conv]]); the program is ill-formed if the
       corresponding non-reference copy-initialization would be
       ill-formed. The result of the call to the conversion function, as
       described for the non-reference copy-initialization, is then used
+      to direct-initialize the reference. For this
+      direct-initialization, user-defined conversions are not
+ considered.
+    - Otherwise, the initializer expression is implicitly converted to a
+ prvalue of type “*cv1* `T1`”. The temporary materialization
+ conversion is applied and the reference is bound to the result.
     If `T1` is reference-related to `T2`:
     - *cv1* shall be the same cv-qualification as, or greater
       cv-qualification than, *cv2*; and
     - if the reference is an rvalue reference, the initializer
       expression shall not be an lvalue.
+    \[*Example 6*:
     ``` cpp
     struct Banana { };
     struct Enigma { operator const Banana(); };
+    struct Alaska { operator Banana&(); };
     void enigmatic() {
       typedef const Banana ConstBanana;
       Banana &&banana1 = ConstBanana(); // ill-formed
       Banana &&banana2 = Enigma();      // ill-formed
+      Banana &&banana3 = Alaska();      // ill-formed
     }
     const double& rcd2 = 2;         // rcd2 refers to temporary with value 2.0
     double&& rrd = 2;               // rrd refers to temporary with value 2.0
     const volatile int cvi = 1;
+    const int& r2 = cvi;            // error: cv-qualifier dropped
+    struct A { operator volatile int&(); } a;
+    const int& r3 = a;              // error: cv-qualifier dropped
+                                    // from result of conversion function
     double d2 = 1.0;
+    double&& rrd2 = d2;             // error: initializer is lvalue of related type
+    struct X { operator int&(); };
+    int&& rri2 = X();               // error: result of conversion function is lvalue of related type
     int i3 = 2;
     double&& rrd3 = i3;             // rrd3 refers to temporary with value 2.0
     ```
+    — *end example*]
+In all cases except the last (i.e., implicitly converting the
+initializer expression to the underlying type of the reference), the
+reference is said to *bind directly* to the initializer expression.
+[*Note 3*:  [[class.temporary]] describes the lifetime of temporaries
+bound to references. — *end note*]
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
 *braced-init-list*. Such an initializer is called an *initializer list*,
 *elements* of the initializer list. An initializer list may be empty.
 List-initialization can occur in direct-initialization or
 copy-initialization contexts; list-initialization in a
 direct-initialization context is called *direct-list-initialization* and
 list-initialization in a copy-initialization context is called
+*copy-list-initialization*.
+[*Note 1*:
+List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
+- as the initializer in a *new-expression* ([[expr.new]])
 - in a return statement ([[stmt.return]])
 - as a *for-range-initializer* ([[stmt.iter]])
 - as a function argument ([[expr.call]])
 - as a subscript ([[expr.sub]])
 - as an argument to a constructor invocation ([[dcl.init]],
   [[expr.type.conv]])
 - as an initializer for a non-static data member ([[class.mem]])
 - in a *mem-initializer* ([[class.base.init]])
 - on the right-hand side of an assignment ([[expr.ass]])
+[*Example 1*:
 ``` cpp
 int a = {1};
 std::complex<double> z{1,2};
 new std::vector<std::string>{"once", "upon", "a", "time"};  // 4 string elements
 f( {"Nicholas","Annemarie"} );  // pass list of two elements
 int* e {};                      // initialization to zero / null pointer
 x = double{1};                  // explicitly construct a double
 std::map<std::string,int> anim = { {"bear",4}, {"cassowary",2}, {"tiger",7} };
 ```
+— *end example*]
+— *end note*]
 A constructor is an *initializer-list constructor* if its first
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
+arguments ([[dcl.fct.default]]).
+[*Note 2*: Initializer-list constructors are favored over other
+constructors in list-initialization ([[over.match.list]]). Passing an
+initializer list as the argument to the constructor template
+`template<class T> C(T)` of a class `C` does not create an
+initializer-list constructor, because an initializer list argument
+causes the corresponding parameter to be a non-deduced context (
+[[temp.deduct.call]]). — *end note*]
+The template `std::initializer_list` is not predefined; if the header
+`<initializer_list>` is not included prior to a use of
+`std::initializer_list` — even an implicit use in which the type is not
+named ([[dcl.spec.auto]]) — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
+- If `T` is an aggregate class and the initializer list has a single
+ element of type *cv* `U`, where `U` is `T` or a class derived from
+  `T`, the object is initialized from that element (by
+  copy-initialization for copy-list-initialization, or by
+  direct-initialization for direct-list-initialization).
+- Otherwise, if `T` is a character array and the initializer list has a
+  single element that is an appropriately-typed string literal (
+  [[dcl.init.string]]), initialization is performed as described in that
+  section.
+- Otherwise, if `T` is an aggregate, aggregate initialization is
+  performed ([[dcl.init.aggr]]).
+  \[*Example 2*:
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
+  — *end example*]
 - Otherwise, if the initializer list has no elements and `T` is a class
   type with a default constructor, the object is value-initialized.
+- Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
+ the object is constructed as described below.
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
   through overload resolution ([[over.match]],  [[over.match.list]]).
   If a narrowing conversion (see below) is required to convert any of
   the arguments, the program is ill-formed.
+  \[*Example 3*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(std::initializer_list<int>);    // #2
     S();                              // #3
   S s1 = { 1.0, 2.0, 3.0 };           // invoke #1
   S s2 = { 1, 2, 3 };                 // invoke #2
   S s3 = { };                         // invoke #3
   ```
+  — *end example*]
+  \[*Example 4*:
   ``` cpp
   struct Map {
     Map(std::initializer_list<std::pair<std::string,int>>);
   };
   Map ship = {{"Sophie",14}, {"Surprise",28}};
   ```
+  — *end example*]
+  \[*Example 5*:
   ``` cpp
   struct S {
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
+  — *end example*]
+- Otherwise, if `T` is an enumeration with a fixed underlying type (
+  [[dcl.enum]]), the *initializer-list* has a single element `v`, and
+  the initialization is direct-list-initialization, the object is
+  initialized with the value `T(v)` ([[expr.type.conv]]); if a
+  narrowing conversion is required to convert `v` to the underlying type
+  of `T`, the program is ill-formed.
+  \[*Example 6*:
+  ``` cpp
+  enum byte : unsigned char { };
+  byte b { 42 };                      // OK
+  byte c = { 42 };                    // error
+  byte d = byte{ 42 };                // OK; same value as b
+  byte e { -1 };                      // error
+  struct A { byte b; };
+  A a1 = { { 42 } };                  // error
+  A a2 = { byte{ 42 } };              // OK
+  void f(byte);
+  f({ 42 });                          // error
+  enum class Handle : uint32_t { Invalid = 0 };
+  Handle h { 42 };                    // OK
+  ```
+  — *end example*]
 - Otherwise, if the initializer list has a single element of type `E`
   and either `T` is not a reference type or its referenced type is
   reference-related to `E`, the object or reference is initialized from
+  that element (by copy-initialization for copy-list-initialization, or
+ by direct-initialization for direct-list-initialization); if a
+  narrowing conversion (see below) is required to convert the element to
+  `T`, the program is ill-formed.
+  \[*Example 7*:
   ``` cpp
   int x1 {2};                         // OK
   int x2 {2.0};                       // error: narrowing
   ```
+ — *end example*]
+- Otherwise, if `T` is a reference type, a prvalue of the type
+ referenced by `T` is generated. The prvalue initializes its result
+ object by copy-list-initialization or direct-list-initialization,
+ depending on the kind of initialization for the reference. The prvalue
+  is then used to direct-initialize the reference.
+  \[*Note 3*: As usual, the binding will fail and the program is
+  ill-formed if the reference type is an lvalue reference to a non-const
+  type. — *end note*]
+  \[*Example 8*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
+  — *end example*]
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
+  \[*Example 9*:
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
+  — *end example*]
 - Otherwise, the program is ill-formed.
+  \[*Example 10*:
   ``` cpp
   struct A { int i; int j; };
   A a1 { 1, 2 };                      // aggregate initialization
   A a2 { 1.2 };                       // error: narrowing
   struct B {
   int j { 1 };                        // initialize to 1
   int k { };                          // initialize to 0
   ```
+  — *end example*]
 Within the *initializer-list* of a *braced-init-list*, the
 *initializer-clause*s, including any that result from pack expansions (
 [[temp.variadic]]), are evaluated in the order in which they appear.
 That is, every value computation and side effect associated with a given
 *initializer-clause* is sequenced before every value computation and
 side effect associated with any *initializer-clause* that follows it in
+the comma-separated list of the *initializer-list*.
+[*Note 4*: This evaluation ordering holds regardless of the semantics
+of the initialization; for example, it applies when the elements of the
+*initializer-list* are interpreted as arguments of a constructor call,
+even though ordinarily there are no sequencing constraints on the
+arguments of a call. — *end note*]
 An object of type `std::initializer_list<E>` is constructed from an
+initializer list as if the implementation generated and materialized (
+[[conv.rval]]) a prvalue of type “array of N `const E`”, where N is the
+number of elements in the initializer list. Each element of that array
+is copy-initialized with the corresponding element of the initializer
+list, and the `std::initializer_list<E>` object is constructed to refer
+to that array.
+[*Note 5*: A constructor or conversion function selected for the copy
+shall be accessible (Clause  [[class.access]]) in the context of the
+initializer list. — *end note*]
+If a narrowing conversion is required to initialize any of the elements,
+the program is ill-formed.
+[*Example 11*:
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
+— *end example*]
 The array has the same lifetime as any other temporary object (
 [[class.temporary]]), except that initializing an `initializer_list`
 object from the array extends the lifetime of the array exactly like
 binding a reference to a temporary.
+[*Example 12*:
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
 struct A {
   std::initializer_list<int> i4;
+  A() : i4{ 1, 2, 3 } {}  // ill-formed, would create a dangling reference
 };
 ```
 For `v1` and `v2`, the `initializer_list` object is a parameter in a
 function call, so the array created for `{ 1, 2, 3 }` has
 full-expression lifetime. For `i3`, the `initializer_list` object is a
 variable, so the array persists for the lifetime of the variable. For
+`i4`, the `initializer_list` object is initialized in the constructor’s
+*ctor-initializer* as if by binding a temporary array to a reference
+member, so the program is ill-formed ([[class.base.init]]).
+— *end example*]
+[*Note 6*: The implementation is free to allocate the array in
+read-only memory if an explicit array with the same initializer could be
+so allocated. — *end note*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from `long double` to `double` or `float`, or from `double` to
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
   where the source is a constant expression whose value after integral
   promotions will fit into the target type.
+[*Note 7*: As indicated above, such conversions are not allowed at the
+top level in list-initializations. — *end note*]
+[*Example 13*:
 ``` cpp
 int x = 999;              // x is not a constant expression
 const int y = 999;
 const int z = 99;
 int f(int);
 int a[] =
   { 2, f(2), f(2.0) };    // OK: the double-to-int conversion is not at the top level
 ```
+— *end example*]
 <!-- Link reference definitions -->
+[basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.def]: basic.md#basic.def
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
+[basic.lookup.classref]: basic.md#basic.lookup.classref
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
 [basic.scope.block]: basic.md#basic.scope.block
+[basic.scope.declarative]: basic.md#basic.scope.declarative
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
+[basic.start.dynamic]: basic.md#basic.start.dynamic
+[basic.start.static]: basic.md#basic.start.static
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
+[basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [basic.types]: basic.md#basic.types
 [class]: class.md#class
 [class.conv]: special.md#class.conv
 [class.conv.ctor]: special.md#class.conv.ctor
 [class.conv.fct]: special.md#class.conv.fct
 [class.copy]: special.md#class.copy
 [class.ctor]: special.md#class.ctor
 [class.dtor]: special.md#class.dtor
 [class.expl.init]: special.md#class.expl.init
 [class.friend]: class.md#class.friend
+[class.inhctor.init]: special.md#class.inhctor.init
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
+[class.mi]: class.md#class.mi
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
 [class.union]: class.md#class.union
+[class.union.anon]: class.md#class.union.anon
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
 [conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
+[conv.qual]: conv.md#conv.qual
+[conv.rval]: conv.md#conv.rval
+[cstddef.syn]: language.md#cstddef.syn
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.deprecated]: #dcl.attr.deprecated
+[dcl.attr.fallthrough]: #dcl.attr.fallthrough
 [dcl.attr.grammar]: #dcl.attr.grammar
+[dcl.attr.nodiscard]: #dcl.attr.nodiscard
 [dcl.attr.noreturn]: #dcl.attr.noreturn
+[dcl.attr.unused]: #dcl.attr.unused
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [dcl.enum]: #dcl.enum
 [dcl.fct]: #dcl.fct
 [dcl.init]: #dcl.init
 [dcl.init.aggr]: #dcl.init.aggr
 [dcl.init.list]: #dcl.init.list
 [dcl.init.ref]: #dcl.init.ref
 [dcl.init.string]: #dcl.init.string
+[dcl.inline]: #dcl.inline
 [dcl.link]: #dcl.link
 [dcl.meaning]: #dcl.meaning
 [dcl.mptr]: #dcl.mptr
 [dcl.name]: #dcl.name
 [dcl.ptr]: #dcl.ptr
 [dcl.ref]: #dcl.ref
 [dcl.spec]: #dcl.spec
 [dcl.spec.auto]: #dcl.spec.auto
 [dcl.stc]: #dcl.stc
+[dcl.struct.bind]: #dcl.struct.bind
 [dcl.type]: #dcl.type
+[dcl.type.auto.deduct]: #dcl.type.auto.deduct
+[dcl.type.class.deduct]: #dcl.type.class.deduct
 [dcl.type.cv]: #dcl.type.cv
 [dcl.type.elab]: #dcl.type.elab
 [dcl.type.simple]: #dcl.type.simple
 [dcl.typedef]: #dcl.typedef
 [except.handle]: except.md#except.handle
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.alignof]: expr.md#expr.alignof
 [expr.cond]: expr.md#expr.cond
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
+[expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
+[expr.prim.this]: expr.md#expr.prim.this
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [expr.unary.op]: expr.md#expr.unary.op
 [intro.compliance]: intro.md#intro.compliance
 [intro.execution]: intro.md#intro.execution
 [intro.multithread]: intro.md#intro.multithread
 [lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
 [over.match]: over.md#over.match
+[over.match.class.deduct]: over.md#over.match.class.deduct
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
 [over.match.ref]: over.md#over.match.ref
 [over.oper]: over.md#over.oper
 [over.sub]: over.md#over.sub
 [stmt.ambig]: stmt.md#stmt.ambig
 [stmt.dcl]: stmt.md#stmt.dcl
+[stmt.expr]: stmt.md#stmt.expr
+[stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
+[stmt.label]: stmt.md#stmt.label
 [stmt.return]: stmt.md#stmt.return
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
+[stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
+[temp.deduct]: temp.md#temp.deduct
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.inst]: temp.md#temp.inst
 [temp.spec]: temp.md#temp.spec
 [temp.variadic]: temp.md#temp.variadic
 [^1]: The “implicit int” rule of C is no longer supported.
+[^2]: The `inline` keyword has no effect on the linkage of a function.
 [^3]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
 [^4]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
+[^5]: this implies that the name of the class or function is
     unqualified.
+[^6]: A *using-declaration* with more than one *using-declarator* is
+    equivalent to a corresponding sequence of *using-declaration*s with
+    one *using-declarator* each.
 [^7]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
+[^8]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
+[^9]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
+[^10]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
+[^11]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
+    [[lex.name]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
+[^12]: As specified in  [[conv.ptr]], converting an integer literal
     whose value is `0` to a pointer type results in a null pointer
     value.
+[^13]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
+[^14]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

Diff to HTML by rtfpessoa