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

Files changed (1) hide show

tmp/tmprq23l_rr/{from.md → to.md} +370 -2174

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

@@ -1,6 +1,6 @@
-# Declarators <a id="dcl.decl">[[dcl.decl]]</a>
 A declarator declares a single variable, function, or type, within a
 declaration. The *init-declarator-list* appearing in a declaration is a
 comma-separated sequence of declarators, each of which can have an
 initializer.
@@ -12,14 +12,15 @@ init-declarator-list:
 ```
 ``` bnf
 init-declarator:
     declarator initializerₒₚₜ
 ```
-The three components of a *simple-declaration* are the attributes (
-[[dcl.attr]]), the specifiers (*decl-specifier-seq*; [[dcl.spec]]) and
 the declarators (*init-declarator-list*). The specifiers indicate the
 type, storage class or other properties of the entities being declared.
 The declarators specify the names of these entities and (optionally)
 modify the type of the specifiers with operators such as `*` (pointer
 to) and `()` (function returning). Initial values can also be specified
@@ -62,12 +63,11 @@ which is not equivalent to
 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
 ```
@@ -78,10 +78,34 @@ 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:
     ptr-declarator
@@ -126,12 +150,12 @@ cv-qualifier-seq:
     cv-qualifier cv-qualifier-seqₒₚₜ
 ```
 ``` bnf
 cv-qualifier:
- 'const'
- 'volatile'
 ```
 ``` bnf
 ref-qualifier:
     '&'
@@ -141,11 +165,11 @@ ref-qualifier:
 ``` 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
 for a variable or function of that type that omits the name of the
@@ -215,14 +239,14 @@ 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
 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
@@ -312,22 +336,22 @@ 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*.
@@ -338,14 +362,15 @@ 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
@@ -371,11 +396,11 @@ 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`”.
@@ -394,11 +419,11 @@ T D1
 ```
 Parentheses do not alter the type of the embedded *declarator-id*, but
 they can alter the binding of complex declarators.
-### Pointers <a id="dcl.ptr">[[dcl.ptr]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
@@ -406,12 +431,12 @@ 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 “*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
@@ -464,14 +489,14 @@ cv-unqualified pointer later, for 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'
@@ -482,18 +507,18 @@ 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`”.
@@ -557,19 +582,19 @@ 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]].
 — *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
@@ -577,15 +602,14 @@ 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*:
@@ -609,11 +633,11 @@ decltype(r2)&& r7 = i;          // r7 has the type int&
 [*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'
@@ -622,11 +646,11 @@ nested-name-specifier '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒ
 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
@@ -657,102 +681,107 @@ 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
 ``` bnf
-'D1 [' constant-expressionₒₚₜ ']' attribute-specifier-seqₒₚₜ
 ```
-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];
-```
-declares an array of `float` numbers and an array of pointers to `float`
-numbers. For another example,
-``` cpp
-static int x3d[3][5][7];
-```
-declares a static three-dimensional array of integers, with rank
-3 × 5 × 7. In complete detail, `x3d` is an array of three items; each
-item is an array of five arrays; each of the latter arrays is an array
-of seven integers. Any of the expressions `x3d`, `x3d[i]`, `x3d[i][j]`,
-`x3d[i][j][k]` can reasonably appear in an expression. Finally,
 ``` cpp
 extern int x[10];
 struct S {
   static int y[10];
@@ -767,102 +796,106 @@ void f() {
 }
 ```
 — *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];
 ```
-Here `x` is a 3 × 5 array of integers. When `x` appears in an
-expression, it is converted to a pointer to (the first of three)
-five-membered arrays of integers. In the expression `x[i]` which is
-equivalent to `*(x+i)`, `x` is first converted to a pointer as
-described; then `x+i` is converted to the type of `x`, which involves
-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.
 — *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
@@ -888,17 +921,18 @@ 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
@@ -913,31 +947,28 @@ 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*`
 — *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*]
@@ -947,20 +978,20 @@ A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 - the function type for a non-static member function,
 - the function type to which a pointer to member refers,
 - the top-level function type of a function typedef declaration or
   *alias-declaration*,
-- 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
 ```
@@ -986,11 +1017,12 @@ struct S {
 — *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*]
@@ -1001,48 +1033,52 @@ 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
@@ -1107,23 +1143,100 @@ 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.
 [*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);
@@ -1139,17 +1252,19 @@ void g() {
 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
@@ -1169,27 +1284,30 @@ 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
 declarations in outer scopes, and vice versa. In a given function
 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).
 [*Example 2*:
 ``` cpp
 void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
@@ -1208,28 +1326,32 @@ void m() {
   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
-template in the translation unit.
 The default argument has the same semantic constraints as the
 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]].
 [*Example 3*:
 In the following code, `g` will be called with the value `f(2)`:
@@ -1248,24 +1370,24 @@ void h() {
 }
 ```
 — *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
-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.
 [*Example 4*:
 ``` cpp
 class C {
@@ -1277,12 +1399,12 @@ void C::f(int i = 3) {}         // error: default argument already specified in
 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() {
@@ -1293,11 +1415,11 @@ void f() {
 }
 ```
 — *end example*]
-[*Note 2*:
 The keyword `this` may not appear in a default argument of a member
 function; see  [[expr.prim.this]].
 [*Example 6*:
@@ -1329,13 +1451,13 @@ 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
@@ -1351,11 +1473,11 @@ class X {
 };
 ```
 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.
@@ -1374,21 +1496,21 @@ 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
 following the redeclaration where the *using-declaration* is in scope.
-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.
 [*Example 10*:
 ``` cpp
 struct A {
@@ -1405,1931 +1527,5 @@ void m() {
 }
 ```
 — *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
-``` bnf
-function-definition:
-    attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ function-body
-```
-``` bnf
-function-body:
-    ctor-initializerₒₚₜ compound-statement
-    function-try-block
-    '= default ;'
-    '= delete ;'
-```
-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]]).
-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
-definition of the form
-``` cpp
-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
-attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ ' = default ;'
-```
-is called an *explicitly-defaulted* definition. A function that is
-explicitly defaulted shall
-- be a special member function,
-- have the same declared function type (except for possibly differing
-  *ref-qualifier*s and except that in the case of a copy constructor or
-  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;
-  trivial(trivial&&) = default;
-  trivial& operator=(const trivial&) = default;
-  trivial& operator=(trivial&&) = default;
-  ~trivial() = default;
-};
-struct nontrivial1 {
-  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
-attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ ' = delete ;'
-```
-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;
-  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.
-``` cpp
-struct moveonly {
-  moveonly() = default;
-  moveonly(const moveonly&) = delete;
-  moveonly(moveonly&&) = default;
-  moveonly& operator=(const moveonly&) = delete;
-  moveonly& operator=(moveonly&&) = default;
-  ~moveonly() = default;
-};
-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 ')'
-```
-``` bnf
-brace-or-equal-initializer:
-    '=' initializer-clause
-    braced-init-list
-```
-``` bnf
-initializer-clause:
-    assignment-expression
-    braced-init-list
-```
-``` bnf
-initializer-list:
-    initializer-clause '...'ₒₚₜ
-    initializer-list ',' initializer-clause '...'ₒₚₜ
-```
-``` bnf
-braced-init-list:
-    '{' initializer-list ','ₒₚₜ '}'
-    '{' '}'
-```
-``` bnf
-expr-or-braced-init-list:
-    expression
-    braced-init-list
-```
-Except for objects declared with the `constexpr` specifier, for which
-see  [[dcl.constexpr]], an *initializer* in the definition of a variable
-can consist of arbitrary expressions involving literals and previously
-declared variables and functions, regardless of the variable’s storage
-duration.
-[*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
-  constructor that is user-provided or deleted, then the object is
-  default-initialized;
-- if `T` is a (possibly cv-qualified) class type without a user-provided
-  or deleted default constructor, then the object is zero-initialized
-  and the semantic constraints for default-initialization are checked,
-  and if `T` has a non-trivial default constructor, the object is
-  default-initialized;
-- if `T` is an array type, then each element is value-initialized;
-- otherwise, the object is zero-initialized.
-A program that calls for default-initialization or value-initialization
-of an entity of reference type is ill-formed.
-[*Note 3*: Every object of static storage duration is zero-initialized
-at program startup before any other initialization takes place. In some
-cases, additional initialization is done later. — *end note*]
-An object whose initializer is an empty set of parentheses, i.e., `()`,
-shall be value-initialized.
-[*Note 4*:
-Since `()` is not permitted by the syntax for *initializer*,
-``` cpp
-X a();
-```
-is not the declaration of an object of class `X`, but the declaration of
-a function taking no argument and returning an `X`. The form `()` is
-permitted in certain other initialization contexts ([[expr.new]],
-[[expr.type.conv]], [[class.base.init]]).
-— *end note*]
-If no initializer is specified for an object, the object is
-default-initialized. When storage for an object with automatic or
-dynamic storage duration is obtained, the object has an *indeterminate
-value*, and if no initialization is performed for the object, that
-object retains an indeterminate value until that value is replaced (
-[[expr.ass]]).
-[*Note 5*: Objects with static or thread storage duration are
-zero-initialized, see  [[basic.start.static]]. — *end note*]
-If an indeterminate value is produced by an evaluation, the behavior is
-undefined except in the following cases:
-- If an indeterminate value of unsigned narrow character type (
-  [[basic.fundamental]]) or `std::byte` type ([[cstddef.syn]]) is
-  produced by the evaluation of:
-  - the second or third operand of a conditional expression (
-    [[expr.cond]]),
-  - the right operand of a comma expression ([[expr.comma]]),
-  - the operand of a cast or conversion ([[conv.integral]],
-    [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]]) to an
-    unsigned narrow character type or `std::byte` type (
-    [[cstddef.syn]]), or
-  - a discarded-value expression (Clause  [[expr]]),
-  then the result of the operation is an indeterminate value.
-- If an indeterminate value of unsigned narrow character type or
-  `std::byte` type is produced by the evaluation of the right operand of
-  a simple assignment operator ([[expr.ass]]) whose first operand is an
-  lvalue of unsigned narrow character type or `std::byte` type, an
-  indeterminate value replaces the value of the object referred to by
-  the left operand.
-- If an indeterminate value of unsigned narrow character type is
-  produced by the evaluation of the initialization expression when
-  initializing an object of unsigned narrow character type, that object
-  is initialized to an indeterminate value.
-- If an indeterminate value of unsigned narrow character type or
-  `std::byte` type is produced by the evaluation of the initialization
-  expression when initializing an object of `std::byte` type, that
-  object is initialized to an indeterminate value.
-[*Example 2*:
-``` cpp
-  int f(bool b) {
-    unsigned char c;
-    unsigned char d = c;        // OK, d has an indeterminate value
-    int e = d;                  // undefined behavior
-    return b ? d : 0;           // undefined behavior if b is true
-  }
-```
-— *end example*]
-An initializer for a static member is in the scope of the member’s
-class.
-[*Example 3*:
-``` cpp
-int a;
-struct X {
-  static int a;
-  static int b;
-};
-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
-    initialization is ill-formed.
-  - Otherwise (i.e., for the remaining copy-initialization cases),
-    user-defined conversion sequences that can convert from the source
-    type to the destination type or (when a conversion function is used)
-    to a derived class thereof are enumerated as described in
-    [[over.match.copy]], and the best one is chosen through overload
-    resolution ([[over.match]]). If the conversion cannot be done or is
-    ambiguous, the initialization is ill-formed. The function selected
-    is called with the initializer expression as its argument; if the
-    function is a constructor, the call is a prvalue of the
-    cv-unqualified version of the destination type whose result object
-    is initialized by the constructor. The call is used to
-    direct-initialize, according to the rules above, the object that is
-    the destination of the copy-initialization.
-- Otherwise, if the source type is a (possibly cv-qualified) class type,
-  conversion functions are considered. The applicable conversion
-  functions are enumerated ([[over.match.conv]]), and the best one is
-  chosen through overload resolution ([[over.match]]). The user-defined
-  conversion so selected is called to convert the initializer expression
-  into the object being initialized. If the conversion cannot be done or
-  is ambiguous, the initialization is ill-formed.
-- Otherwise, the initial value of the object being initialized is the
-  (possibly converted) value of the initializer expression. Standard
-  conversions (Clause  [[conv]]) will be used, if necessary, to convert
-  the initializer expression to the cv-unqualified version of the
-  destination type; no user-defined conversions are considered. If the
-  conversion cannot be done, the initialization is ill-formed. When
-  initializing a bit-field with a value that it cannot represent, the
-  resulting value of the bit-field is *implementation-defined*.
-  \[*Note 7*:
-  An expression of type “*cv1* `T`” can initialize an object of type
-  “*cv2* `T`” independently of the cv-qualifiers *cv1* and *cv2*.
-  ``` cpp
-  int a;
-  const int b = a;
-  int c = b;
-  ```
-  — *end note*]
-An *initializer-clause* followed by an ellipsis is a pack expansion (
-[[temp.variadic]]).
-If the initializer is a parenthesized *expression-list*, the expressions
-are evaluated in the order specified for function calls (
-[[expr.call]]).
-An object whose initialization has completed is deemed to be
-constructed, even if no constructor of the object’s class is invoked for
-the initialization.
-[*Note 8*: Such an object might have been value-initialized or
-initialized by aggregate initialization ([[dcl.init.aggr]]) or by an
-inherited constructor ([[class.inhctor.init]]). — *end note*]
-A declaration that specifies the initialization of a variable, whether
-from an explicit initializer or by default-initialization, is called the
-*initializing declaration* of that variable.
-[*Note 9*: In most cases this is the defining declaration (
-[[basic.def]]) of the variable, but the initializing declaration of a
-non-inline static data member ([[class.static.data]]) might be the
-declaration within the class definition and not the definition at
-namespace scope. — *end note*]
-### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
-An *aggregate* is an array or a class (Clause  [[class]]) with
-- no user-provided, `explicit`, or inherited constructors (
-  [[class.ctor]]),
-- no private or protected non-static data members (Clause
-  [[class.access]]),
-- no virtual functions ([[class.virtual]]), and
-- no virtual, private, or protected base classes ([[class.mi]]).
-[*Note 1*: Aggregate initialization does not allow accessing protected
-and private base class’ members or constructors. — *end note*]
-The *elements* of an aggregate are:
-- for an array, the array elements in increasing subscript order, or
-- for a class, the direct base classes in declaration order, followed by
-  the direct non-static data members ([[class.mem]]) that are not
-  members of an anonymous union, in declaration order.
-When an aggregate is initialized by an initializer list as specified in
-[[dcl.init.list]], the elements of the initializer list are taken as
-initializers for the elements of the aggregate, in order. Each element
-is copy-initialized from the corresponding *initializer-clause*. If the
-*initializer-clause* is an expression and a narrowing conversion (
-[[dcl.init.list]]) is required to convert the expression, the program is
-ill-formed.
-[*Note 2*: If an *initializer-clause* is itself an initializer list,
-the element is list-initialized, which will result in a recursive
-application of the rules in this section if the element is an
-aggregate. — *end note*]
-[*Example 1*:
-``` cpp
-struct A {
-  int x;
-  struct B {
-    int i;
-    int j;
-  } 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;
-  int j;
-  int :17;
-  int k;
-} 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" };
-```
-initializes `ss.a` with 1, `ss.b` with `"asdf"`, `ss.c` with the value
-of an expression of the form `int{}` (that is, `0`), and `ss.d` with the
-value of `ss.b[ss.a]` (that is, `'s'`), and in
-``` cpp
-struct X { int i, j, k = 42; };
-X a[] = { 1, 2, 3, 4, 5, 6 };
-X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
-```
-`a` and `b` have the same value
-— *end example*]
-If a reference member is initialized from its default member initializer
-and a potentially-evaluated subexpression thereof is an aggregate
-initialization that would use that default member initializer, the
-program is ill-formed.
-[*Example 7*:
-``` cpp
-  struct A;
-  extern A a;
-  struct A {
-    const A& a1 { A{a,a} };     // OK
-    const A& a2 { A{} };        // error
-  };
-  A a{a,a};                     // OK
-```
-— *end example*]
-If an aggregate class `C` contains a subaggregate element `e` with no
-elements, the *initializer-clause* for `e` shall not be omitted from an
-*initializer-list* for an object of type `C` unless the
-*initializer-clause*s for all elements of `C` following `e` are also
-omitted.
-[*Example 8*:
-``` cpp
-struct S { } s;
-struct A {
-  S s1;
-  int i1;
-  S s2;
-  int i2;
-  S s3;
-  int i3;
-} a = {
-  { },              // Required initialization
-  0,
-  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
-`x[1][1]` to `2`. On the other hand,
-``` cpp
-float y[4][3] = {
-  { 1 }, { 2 }, { 3 }, { 4 }
-};
-```
-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 },
-  { 3, 5, 7 },
-};
-```
-is a completely-braced initialization: 1, 3, and 5 initialize the first
-row of the array `y[0]`, namely `y[0][0]`, `y[0][1]`, and `y[0][2]`.
-Likewise the next two lines initialize `y[1]` and `y[2]`. The
-initializer ends early and therefore `y[3]`s elements are initialized as
-if explicitly initialized with an expression of the form `float()`, that
-is, are initialized with `0.0`. In the following example, braces in the
-*initializer-list* are elided; however the *initializer-list* has the
-same effect as the completely-braced *initializer-list* of the above
-example,
-``` cpp
-float y[4][3] = {
-  1, 3, 5, 2, 4, 6, 3, 5, 7
-};
-```
-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();
-};
-struct B {
-  A a1, a2;
-  int z;
-};
-A a;
-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.
-— *end example*]
-[*Note 6*: An aggregate array or an aggregate class may contain
-elements of a class type with a user-provided constructor (
-[[class.ctor]]). Initialization of these aggregate objects is described
-in  [[class.expl.init]]. — *end note*]
-[*Note 7*: Whether the initialization of aggregates with static storage
-duration is static or dynamic is specified in  [[basic.start.static]],
-[[basic.start.dynamic]], and  [[stmt.dcl]]. — *end note*]
-When a union is initialized with a brace-enclosed initializer, the
-braces shall only contain an *initializer-clause* for the first
-non-static data member of the union.
-[*Example 12*:
-``` cpp
-union u { int a; const char* b; };
-u a = { 1 };
-u b = a;
-u c = 1;                        // error
-u d = { 0, "asdf" };            // error
-u e = { "asdf" };               // error
-```
-— *end example*]
-[*Note 8*: As described above, the braces around the
-*initializer-clause* for a union member can be omitted if the union is a
-member of another aggregate. — *end note*]
-### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
-An array of narrow character type ([[basic.fundamental]]), `char16_t`
-array, `char32_t` array, or `wchar_t` array can be initialized by a
-narrow string literal, `char16_t` string literal, `char32_t` string
-literal, or wide string literal, respectively, or by an
-appropriately-typed string literal enclosed in braces ([[lex.string]]).
-Successive characters of the value of the string literal initialize the
-elements of the array.
-[*Example 1*:
-``` cpp
-char msg[] = "Syntax error on line %s\n";
-```
-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& rr = r;                  // rr refers to what r refers to, that is, to i
-  int (&rg)(int) = g;           // rg refers to the function g
-  rg(i);                        // calls function g
-  int a[3];
-  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 A { };
-  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.
-    A&& rra = f();                      // same as above
-    struct X {
-      operator B();
-      operator int&();
-    } 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*,
-and the comma-separated *initializer-clause*s of the list are called the
-*elements* of the initializer list. An initializer list may be empty.
-List-initialization can occur in direct-initialization or
-copy-initialization contexts; list-initialization in a
-direct-initialization context is called *direct-list-initialization* and
-list-initialization in a copy-initialization context is called
-*copy-list-initialization*.
-[*Note 1*:
-List-initialization can be used
-- as the initializer in a variable definition ([[dcl.init]])
-- as the initializer in a *new-expression* ([[expr.new]])
-- in a return statement ([[stmt.return]])
-- as a *for-range-initializer* ([[stmt.iter]])
-- as a function argument ([[expr.call]])
-- as a subscript ([[expr.sub]])
-- as an argument to a constructor invocation ([[dcl.init]],
-  [[expr.type.conv]])
-- as an initializer for a non-static data member ([[class.mem]])
-- in a *mem-initializer* ([[class.base.init]])
-- on the right-hand side of an assignment ([[expr.ass]])
-[*Example 1*:
-``` cpp
-int a = {1};
-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
-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} };
-```
-— *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 {
-    int m1;
-    double m2, m3;
-  };
-  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
-    // ...
-  };
-  const S& r1 = { 1, 2, 3.0 };        // OK: invoke #1
-  const S& r2 { "Spinach" };          // OK: invoke #2
-  S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
-  const int& i1 = { 1 };              // OK
-  const int& i2 = { 1.1 };            // error: narrowing
-  const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
-  ```
-  — *end example*]
-- Otherwise, if the initializer list has no elements, the object is
-  value-initialized.
-  \[*Example 9*:
-  ``` cpp
-  int** pp {};                        // initialized to null pointer
-  ```
-  — *end example*]
-- Otherwise, the program is ill-formed.
-  \[*Example 10*:
-  ``` cpp
-  struct A { int i; int j; };
-  A a1 { 1, 2 };                      // aggregate initialization
-  A a2 { 1.2 };                       // error: narrowing
-  struct B {
-    B(std::initializer_list<int>);
-  };
-  B b1 { 1, 2 };                      // creates initializer_list<int> and calls constructor
-  B b2 { 1, 2.0 };                    // error: narrowing
-  struct C {
-    C(int i, double j);
-  };
-  C c1 = { 1, 2.2 };                  // calls constructor with arguments (1, 2.2)
-  C c2 = { 1.1, 2 };                  // error: narrowing
-  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);
-};
-X x{ 1,2,3 };
-```
-The initialization will be implemented in a way roughly equivalent to
-this:
-``` cpp
-const double __a[3] = {double{1}, double{2}, double{3}};
-X x(std::initializer_list<double>(__a, __a+3));
-```
-assuming that the implementation can construct an `initializer_list`
-object with a pair of pointers.
-— *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::vector<cmplx> v2{ 1, 2, 3 };
-  std::initializer_list<int> i3 = { 1, 2, 3 };
-}
-struct A {
-  std::initializer_list<int> i4;
-  A() : i4{ 1, 2, 3 } {}  // 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
-  `float`, except where the source is a constant expression and the
-  actual value after conversion is within the range of values that can
-  be represented (even if it cannot be represented exactly), or
-- from an integer type or unscoped enumeration type to a floating-point
-  type, except where the source is a constant expression and the actual
-  value after conversion will fit into the target type and will produce
-  the original value when converted back to the original type, or
-- from an integer type or unscoped enumeration type to an integer type
-  that cannot represent all the values of the original type, except
-  where the source is a constant expression whose value after integral
-  promotions will fit into the target type.
-[*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;
-char c1 = x;              // OK, though it might narrow (in this case, it does narrow)
-char c2{x};               // error: might narrow
-char c3{y};               // error: narrows (assuming char is 8 bits)
-char c4{z};               // OK: no narrowing needed
-unsigned char uc1 = {5};  // OK: no narrowing needed
-unsigned char uc2 = {-1}; // error: narrows
-unsigned int ui1 = {-1};  // error: narrows
-signed int si1 =
-  { (unsigned int)-1 };   // error: narrows
-int ii = {2.0};           // error: narrows
-float f1 { x };           // error: might narrow
-float f2 { 7 };           // OK: 7 can be exactly represented as a float
-int f(int);
-int a[] =
-  { 2, f(2), f(2.0) };    // OK: the double-to-int conversion is not at the top level
-```
-— *end example*]
-<!-- Link reference definitions -->
-[basic.align]: basic.md#basic.align
-[basic.compound]: basic.md#basic.compound
-[basic.def]: basic.md#basic.def
-[basic.def.odr]: basic.md#basic.def.odr
-[basic.fundamental]: basic.md#basic.fundamental
-[basic.life]: basic.md#basic.life
-[basic.link]: basic.md#basic.link
-[basic.lookup]: basic.md#basic.lookup
-[basic.lookup.argdep]: basic.md#basic.lookup.argdep
-[basic.lookup.classref]: basic.md#basic.lookup.classref
-[basic.lookup.elab]: basic.md#basic.lookup.elab
-[basic.lookup.qual]: basic.md#basic.lookup.qual
-[basic.lookup.udir]: basic.md#basic.lookup.udir
-[basic.lookup.unqual]: basic.md#basic.lookup.unqual
-[basic.lval]: basic.md#basic.lval
-[basic.namespace]: #basic.namespace
-[basic.scope]: basic.md#basic.scope
-[basic.scope.block]: basic.md#basic.scope.block
-[basic.scope.declarative]: basic.md#basic.scope.declarative
-[basic.scope.namespace]: basic.md#basic.scope.namespace
-[basic.scope.pdecl]: basic.md#basic.scope.pdecl
-[basic.scope.proto]: basic.md#basic.scope.proto
-[basic.start]: basic.md#basic.start
-[basic.start.dynamic]: basic.md#basic.start.dynamic
-[basic.start.static]: basic.md#basic.start.static
-[basic.stc]: basic.md#basic.stc
-[basic.stc.auto]: basic.md#basic.stc.auto
-[basic.stc.dynamic]: basic.md#basic.stc.dynamic
-[basic.stc.static]: basic.md#basic.stc.static
-[basic.stc.thread]: basic.md#basic.stc.thread
-[basic.type.qualifier]: basic.md#basic.type.qualifier
-[basic.types]: basic.md#basic.types
-[class]: class.md#class
-[class.access]: class.md#class.access
-[class.base.init]: special.md#class.base.init
-[class.bit]: class.md#class.bit
-[class.conv]: special.md#class.conv
-[class.conv.ctor]: special.md#class.conv.ctor
-[class.conv.fct]: special.md#class.conv.fct
-[class.copy]: special.md#class.copy
-[class.ctor]: special.md#class.ctor
-[class.dtor]: special.md#class.dtor
-[class.expl.init]: special.md#class.expl.init
-[class.friend]: class.md#class.friend
-[class.inhctor.init]: special.md#class.inhctor.init
-[class.init]: special.md#class.init
-[class.mem]: class.md#class.mem
-[class.member.lookup]: class.md#class.member.lookup
-[class.mfct]: class.md#class.mfct
-[class.mi]: class.md#class.mi
-[class.name]: class.md#class.name
-[class.qual]: basic.md#class.qual
-[class.static]: class.md#class.static
-[class.static.data]: class.md#class.static.data
-[class.temporary]: special.md#class.temporary
-[class.union]: class.md#class.union
-[class.union.anon]: class.md#class.union.anon
-[class.virtual]: class.md#class.virtual
-[conv]: conv.md#conv
-[conv.array]: conv.md#conv.array
-[conv.func]: conv.md#conv.func
-[conv.integral]: conv.md#conv.integral
-[conv.lval]: conv.md#conv.lval
-[conv.prom]: conv.md#conv.prom
-[conv.ptr]: conv.md#conv.ptr
-[conv.qual]: conv.md#conv.qual
-[conv.rval]: conv.md#conv.rval
-[cstddef.syn]: language.md#cstddef.syn
-[dcl.align]: #dcl.align
-[dcl.ambig.res]: #dcl.ambig.res
-[dcl.array]: #dcl.array
-[dcl.asm]: #dcl.asm
-[dcl.attr]: #dcl.attr
-[dcl.attr.depend]: #dcl.attr.depend
-[dcl.attr.deprecated]: #dcl.attr.deprecated
-[dcl.attr.fallthrough]: #dcl.attr.fallthrough
-[dcl.attr.grammar]: #dcl.attr.grammar
-[dcl.attr.nodiscard]: #dcl.attr.nodiscard
-[dcl.attr.noreturn]: #dcl.attr.noreturn
-[dcl.attr.unused]: #dcl.attr.unused
-[dcl.constexpr]: #dcl.constexpr
-[dcl.dcl]: #dcl.dcl
-[dcl.decl]: #dcl.decl
-[dcl.enum]: #dcl.enum
-[dcl.fct]: #dcl.fct
-[dcl.fct.def]: #dcl.fct.def
-[dcl.fct.def.default]: #dcl.fct.def.default
-[dcl.fct.def.delete]: #dcl.fct.def.delete
-[dcl.fct.def.general]: #dcl.fct.def.general
-[dcl.fct.default]: #dcl.fct.default
-[dcl.fct.spec]: #dcl.fct.spec
-[dcl.friend]: #dcl.friend
-[dcl.init]: #dcl.init
-[dcl.init.aggr]: #dcl.init.aggr
-[dcl.init.list]: #dcl.init.list
-[dcl.init.ref]: #dcl.init.ref
-[dcl.init.string]: #dcl.init.string
-[dcl.inline]: #dcl.inline
-[dcl.link]: #dcl.link
-[dcl.meaning]: #dcl.meaning
-[dcl.mptr]: #dcl.mptr
-[dcl.name]: #dcl.name
-[dcl.ptr]: #dcl.ptr
-[dcl.ref]: #dcl.ref
-[dcl.spec]: #dcl.spec
-[dcl.spec.auto]: #dcl.spec.auto
-[dcl.stc]: #dcl.stc
-[dcl.struct.bind]: #dcl.struct.bind
-[dcl.type]: #dcl.type
-[dcl.type.auto.deduct]: #dcl.type.auto.deduct
-[dcl.type.class.deduct]: #dcl.type.class.deduct
-[dcl.type.cv]: #dcl.type.cv
-[dcl.type.elab]: #dcl.type.elab
-[dcl.type.simple]: #dcl.type.simple
-[dcl.typedef]: #dcl.typedef
-[except.handle]: except.md#except.handle
-[except.spec]: except.md#except.spec
-[except.throw]: except.md#except.throw
-[expr]: expr.md#expr
-[expr.alignof]: expr.md#expr.alignof
-[expr.ass]: expr.md#expr.ass
-[expr.call]: expr.md#expr.call
-[expr.cast]: expr.md#expr.cast
-[expr.comma]: expr.md#expr.comma
-[expr.cond]: expr.md#expr.cond
-[expr.const]: expr.md#expr.const
-[expr.const.cast]: expr.md#expr.const.cast
-[expr.mptr.oper]: expr.md#expr.mptr.oper
-[expr.new]: expr.md#expr.new
-[expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
-[expr.prim.this]: expr.md#expr.prim.this
-[expr.ref]: expr.md#expr.ref
-[expr.static.cast]: expr.md#expr.static.cast
-[expr.sub]: expr.md#expr.sub
-[expr.type.conv]: expr.md#expr.type.conv
-[expr.unary]: expr.md#expr.unary
-[expr.unary.op]: expr.md#expr.unary.op
-[intro.compliance]: intro.md#intro.compliance
-[intro.execution]: intro.md#intro.execution
-[intro.multithread]: intro.md#intro.multithread
-[lex.charset]: lex.md#lex.charset
-[lex.digraph]: lex.md#lex.digraph
-[lex.key]: lex.md#lex.key
-[lex.name]: lex.md#lex.name
-[lex.string]: lex.md#lex.string
-[namespace.alias]: #namespace.alias
-[namespace.def]: #namespace.def
-[namespace.memdef]: #namespace.memdef
-[namespace.qual]: basic.md#namespace.qual
-[namespace.udecl]: #namespace.udecl
-[namespace.udir]: #namespace.udir
-[namespace.unnamed]: #namespace.unnamed
-[over]: over.md#over
-[over.match]: over.md#over.match
-[over.match.class.deduct]: over.md#over.match.class.deduct
-[over.match.conv]: over.md#over.match.conv
-[over.match.copy]: over.md#over.match.copy
-[over.match.ctor]: over.md#over.match.ctor
-[over.match.list]: over.md#over.match.list
-[over.match.ref]: over.md#over.match.ref
-[over.oper]: over.md#over.oper
-[over.sub]: over.md#over.sub
-[stmt.ambig]: stmt.md#stmt.ambig
-[stmt.dcl]: stmt.md#stmt.dcl
-[stmt.expr]: stmt.md#stmt.expr
-[stmt.if]: stmt.md#stmt.if
-[stmt.iter]: stmt.md#stmt.iter
-[stmt.label]: stmt.md#stmt.label
-[stmt.return]: stmt.md#stmt.return
-[stmt.select]: stmt.md#stmt.select
-[stmt.stmt]: stmt.md#stmt.stmt
-[stmt.switch]: stmt.md#stmt.switch
-[support.runtime]: language.md#support.runtime
-[tab:simple.type.specifiers]: #tab:simple.type.specifiers
-[temp]: temp.md#temp
-[temp.arg.type]: temp.md#temp.arg.type
-[temp.class.spec]: temp.md#temp.class.spec
-[temp.deduct]: temp.md#temp.deduct
-[temp.deduct.call]: temp.md#temp.deduct.call
-[temp.dep]: temp.md#temp.dep
-[temp.expl.spec]: temp.md#temp.expl.spec
-[temp.explicit]: temp.md#temp.explicit
-[temp.inst]: temp.md#temp.inst
-[temp.mem]: temp.md#temp.mem
-[temp.names]: temp.md#temp.names
-[temp.param]: temp.md#temp.param
-[temp.res]: temp.md#temp.res
-[temp.spec]: temp.md#temp.spec
-[temp.variadic]: temp.md#temp.variadic
-[^1]: The “implicit int” rule of C is no longer supported.
-[^2]: The `inline` keyword has no effect on the linkage of a function.
-[^3]: There is no special provision for a *decl-specifier-seq* that
-    lacks a *type-specifier* or that has a *type-specifier* that only
-    specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
-    supported.
-[^4]: This set of values is used to define promotion and conversion
-    semantics for the enumeration type. It does not preclude an
-    expression of enumeration type from having a value that falls
-    outside this range.
-[^5]: this implies that the name of the class or function is
-    unqualified.
-[^6]: A *using-declaration* with more than one *using-declarator* is
-    equivalent to a corresponding sequence of *using-declaration*s with
-    one *using-declarator* each.
-[^7]: During name lookup in a class hierarchy, some ambiguities may be
-    resolved by considering whether one member hides the other along
-    some paths ([[class.member.lookup]]). There is no such
-    disambiguation when considering the set of names found as a result
-    of following *using-directive*s.
-[^8]: As indicated by syntax, cv-qualifiers are a significant component
-    in function return types.
-[^9]: One can explicitly disambiguate the parse either by introducing a
-    comma (so the ellipsis will be parsed as part of the
-    *parameter-declaration-clause*) or by introducing a name for the
-    parameter (so the ellipsis will be parsed as part of the
-    *declarator-id*).
-[^10]: This means that default arguments cannot appear, for example, in
-    declarations of pointers to functions, references to functions, or
-    `typedef` declarations.
-[^11]: Implementations are permitted to provide additional predefined
-    variables with names that are reserved to the implementation (
-    [[lex.name]]). If a predefined variable is not odr-used (
-    [[basic.def.odr]]), its string value need not be present in the
-    program image.
-[^12]: As specified in  [[conv.ptr]], converting an integer literal
-    whose value is `0` to a pointer type results in a null pointer
-    value.
-[^13]: The syntax provides for empty *initializer-list*s, but
-    nonetheless C++does not have zero length arrays.
-[^14]: This requires a conversion function ([[class.conv.fct]])
-    returning a reference type.

+## Declarators <a id="dcl.decl">[[dcl.decl]]</a>
 A declarator declares a single variable, function, or type, within a
 declaration. The *init-declarator-list* appearing in a declaration is a
 comma-separated sequence of declarators, each of which can have an
 initializer.
 ```
 ``` bnf
 init-declarator:
     declarator initializerₒₚₜ
+    declarator requires-clause
 ```
+The three components of a *simple-declaration* are the attributes
+[[dcl.attr]], the specifiers (*decl-specifier-seq*; [[dcl.spec]]) and
 the declarators (*init-declarator-list*). The specifiers indicate the
 type, storage class or other properties of the entities being declared.
 The declarators specify the names of these entities and (optionally)
 modify the type of the specifiers with operators such as `*` (pointer
 to) and `()` (function returning). Initial values can also be specified
 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
 ```
 auto j = 2.0;           // OK: j deduced to have type double
 ```
 — *end note*]
+The optional *requires-clause* [[temp.pre]] in an *init-declarator* or
+*member-declarator* shall be present only if the declarator declares a
+templated function [[dcl.fct]]. When present after a declarator, the
+*requires-clause* is called the *trailing *requires-clause**. The
+trailing *requires-clause* introduces the *constraint-expression* that
+results from interpreting its *constraint-logical-or-expression* as a
+*constraint-expression*.
+[*Example 1*:
+``` cpp
+void f1(int a) requires true;               // error: non-templated function
+template<typename T>
+  auto f2(T a) -> bool requires true;       // OK
+template<typename T>
+  auto f3(T a) requires true -> bool;       // error: requires-clause precedes trailing-return-type
+void (*pf)() requires true;                 // error: constraint on a variable
+void g(int (*)() requires true);            // error: constraint on a parameter-declaration
+auto* p = new void(*)(char) requires true;  // error: not a function declaration
+```
+— *end example*]
 Declarators have the syntax
 ``` bnf
 declarator:
     ptr-declarator
     cv-qualifier cv-qualifier-seqₒₚₜ
 ```
 ``` bnf
 cv-qualifier:
+    const
+    volatile
 ```
 ``` bnf
 ref-qualifier:
     '&'
 ``` 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
 for a variable or function of that type that omits the name of the
 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
 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
                                 // 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*.
 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`, or `typedef` specifier or an
+*explicit-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
 ``` 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`”.
 ```
 Parentheses do not alter the type of the embedded *declarator-id*, but
 they can alter the binding of complex declarators.
+#### Pointers <a id="dcl.ptr">[[dcl.ptr]]</a>
 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
 “*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
 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'
 “*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;   // error: lvalue reference to non-const initialized with rvalue
 ```
 The type of `aref` is “lvalue reference to `int`”, not “lvalue reference
 to `const int`”.
 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
 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*:
 [*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
 (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
 ``` bnf
+'D1' '[' constant-expressionₒₚₜ ']' 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* array of `N`
+`T`”. The *constant-expression* shall be a converted constant expression
+of type `std::size_t` [[expr.const]]. Its value `N` specifies the *array
+bound*, i.e., the number of elements in the array; `N` shall be greater
+than zero.
+In a declaration `T` `D` where `D` has the form
+``` bnf
+'D1 [ ]' 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* array of
+unknown bound of `T`”, except as specified below.
+A type of the form “array of `N` `U`” or “array of unknown bound of `U`”
+is an *array type*. The optional *attribute-specifier-seq* appertains to
+the array type.
+`U` is called the array *element type*; this type shall not be a
+placeholder type [[dcl.spec.auto]], a reference type, a function type,
+an array of unknown bound, or cv `void`.
+[*Note 1*: 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 an array of known
+bound. — *end note*]
 [*Example 1*:
+``` cpp
+float fa[17], *afp[17];
+```
+declares an array of `float` numbers and an array of pointers to `float`
+numbers.
+— *end example*]
+Any type of the form “*cv-qualifier-seq* array of `N` `U`” is adjusted
+to “array of `N` *cv-qualifier-seq* `U`”, and similarly for “array of
+unknown bound of `U`”.
+[*Example 2*:
 ``` 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 2*: An “array of `N` *cv-qualifier-seq* `U`” has cv-qualified
 type; see  [[basic.type.qualifier]]. — *end note*]
+An object of type “array of `N` `U`” contains a contiguously allocated
+non-empty set of `N` subobjects of type `U`, known as the *elements* of
+the array, and numbered `0` to `N-1`.
+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 an object (but not a non-static data member) of array type is
+initialized and the declarator is followed by an initializer (
+[[dcl.init]], [[class.mem]], [[expr.type.conv]], [[expr.new]]). In these
+cases, the array bound is calculated from the number of initial elements
+(say, `N`) supplied [[dcl.init.aggr]], and the type of the array is
+“array of `N` `U`”.
+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 3*:
 ``` cpp
 extern int x[10];
 struct S {
   static int y[10];
 }
 ```
 — *end example*]
+[*Note 3*:
+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.
+[*Example 4*:
 ``` cpp
+int x3d[3][5][7];
 ```
+declares an array of three elements, each of which is an array of five
+elements, each of which is an array of seven integers. The overall array
+can be viewed as a three-dimensional array of integers, with rank
+3 × 5 × 7. Any of the expressions `x3d`, `x3d[i]`, `x3d[i][j]`,
+`x3d[i][j][k]` can reasonably appear in an expression. The expression
+`x3d[i]` is equivalent to `*(x3d + i)`; in that expression, `x3d` is
+subject to the array-to-pointer conversion [[conv.array]] and is first
+converted to a pointer to a 2-dimensional array with rank 5 × 7 that
+points to the first element of `x3d`. Then `i` is added, which on
+typical implementations involves multiplying `i` by the length of the
+object to which the pointer points, which is `sizeof(int)`× 5 × 7. The
+result of the addition and indirection is an lvalue denoting the `i`ᵗʰ
+array element of `x3d` (an array of five arrays of seven integers). If
+there is another subscript, the same argument applies again, so
+`x3d[i][j]` is an lvalue denoting the `j`ᵗʰ array element of the `i`ᵗʰ
+array element of `x3d` (an array of seven integers), and `x3d[i][j][k]`
+is an lvalue denoting the `k`ᵗʰ array element of the `j`ᵗʰ array element
+of the `i`ᵗʰ array element of `x3d` (an integer).
 — *end example*]
+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*]
+[*Note 4*: Conversions affecting expressions of array type are
+described in  [[conv.array]]. — *end note*]
+[*Note 5*: The subscript operator can be overloaded for a class
+[[over.sub]]. For the operator’s built-in meaning, see
+[[expr.sub]]. — *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-type-list *cv-qualifier-seq*ₒₚₜ
+*ref-qualifier*ₒₚₜ  returning `T`”, where
+- the parameter-type-list is derived from the
+  *parameter-declaration-clause* as described below and
+- 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-type-list *cv-qualifier-seq*ₒₚₜ  *ref-qualifier*ₒₚₜ  returning
+`U`”, where
+- the parameter-type-list is derived from the
+  *parameter-declaration-clause* as described below,
+- `U` is the type specified by the *trailing-return-type*, and
+- 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*.[^2]
 ``` bnf
 parameter-declaration-clause:
     parameter-declaration-listₒₚₜ '...'ₒₚₜ
+    parameter-declaration-list ',' '...'
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
 [[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`.
+A parameter with volatile-qualified type is deprecated; see
+[[depr.volatile.type]]. 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
 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*]
+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*]
 - the function type for a non-static member function,
 - the function type to which a pointer to member refers,
 - the top-level function type of a function typedef declaration or
   *alias-declaration*,
+- 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;              // error: does not declare a member function
 struct S {
   FIC f;            // OK
 };
 FIC S::*pm = &S::f; // OK
 ```
 — *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]] or the trailing *requires-clause*
+[[dcl.decl]], 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*]
 ``` cpp
 int fseek(FILE*, long, int);
 ```
 declares a function taking three arguments of the specified types, and
+returning `int` [[dcl.type]].
 — *end example*]
+A single name can be used for several different functions in a single
+scope; this is function overloading [[over]]. All declarations for a
+function shall have equivalent return types, parameter-type-lists, and
+*requires-clause*s [[temp.over.link]].
 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.
+A volatile-qualified return type is deprecated; see
+[[depr.volatile.type]].
+Types shall not be defined in return or parameter types.
 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 { }           // error
 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.param]]. — *end note*]
 [*Example 6*:
 The declaration
 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*]
+An *abbreviated function template* is a function declaration that has
+one or more generic parameter type placeholders [[dcl.spec.auto]]. An
+abbreviated function template is equivalent to a function template
+[[temp.fct]] whose *template-parameter-list* includes one invented type
+*template-parameter* for each generic parameter type placeholder of the
+function declaration, in order of appearance. For a
+*placeholder-type-specifier* of the form `auto`, the invented parameter
+is an unconstrained *type-parameter*. For a *placeholder-type-specifier*
+of the form *type-constraint* `auto`, the invented parameter is a
+*type-parameter* with that *type-constraint*. The invented type
+*template-parameter* is a template parameter pack if the corresponding
+*parameter-declaration* declares a function parameter pack [[dcl.fct]].
+If the placeholder contains `decltype(auto)`, the program is ill-formed.
+The adjusted function parameters of an abbreviated function template are
+derived from the *parameter-declaration-clause* by replacing each
+occurrence of a placeholder with the name of the corresponding invented
+*template-parameter*.
+[*Example 7*:
+``` cpp
+template<typename T>     concept C1 = /* ... */;
+template<typename T>     concept C2 = /* ... */;
+template<typename... Ts> concept C3 = /* ... */;
+void g1(const C1 auto*, C2 auto&);
+void g2(C1 auto&...);
+void g3(C3 auto...);
+void g4(C3 auto);
+```
+These declarations are functionally equivalent (but not equivalent) to
+the following declarations.
+``` cpp
+template<C1 T, C2 U> void g1(const T*, U&);
+template<C1... Ts>   void g2(Ts&...);
+template<C3... Ts>   void g3(Ts...);
+template<C3 T>       void g4(T);
+```
+Abbreviated function templates can be specialized like all function
+templates.
+``` cpp
+template<> void g1<int>(const int*, const double&); // OK, specialization of g1<int, const double>
+```
+— *end example*]
+An abbreviated function template can have a *template-head*. The
+invented *template-parameters* are appended to the
+*template-parameter-list* after the explicitly declared
+*template-parameters*.
+[*Example 8*:
+``` cpp
+template<typename> concept C = /* ... */;
+template <typename T, C U>
+  void g(T x, U y, C auto z);
+```
+This is functionally equivalent to each of the following two
+declarations.
+``` cpp
+template<typename T, C U, C W>
+  void g(T x, U y, W z);
+template<typename T, typename U, typename W>
+  requires C<U> && C<W>
+  void g(T x, U y, W z);
+```
+— *end example*]
+A function declaration at block scope shall not declare an abbreviated
+function template.
 A *declarator-id* or *abstract-declarator* containing an ellipsis shall
+only be used in a *parameter-declaration*. When it is part of a
+*parameter-declaration-clause*, the *parameter-declaration* declares a
+function parameter pack [[temp.variadic]]. Otherwise, the
+*parameter-declaration* is part of a *template-parameter-list* and
+declares a template parameter pack; see  [[temp.param]]. A function
+parameter pack is a pack expansion [[temp.variadic]].
+[*Example 9*:
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
 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*.[^3]
+#### 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.
+[*Note 1*: Default arguments will be used in calls where trailing
+arguments are missing [[expr.call]]. — *end note*]
 [*Example 1*:
 The declaration
 — *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
+template parameter pack or a function 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*.[^4]
 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
 declarations in outer scopes, and vice versa. In a given function
 declaration, each parameter subsequent to a parameter with a default
 argument shall have a default argument supplied in this or a previous
+declaration, unless the parameter was expanded from a parameter pack, or
+shall be a function parameter pack.
+[*Note 2*: A default argument cannot be redefined by a later
+declaration (not even to the same value)
+[[basic.def.odr]]. — *end note*]
 [*Example 2*:
 ``` cpp
 void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
   void f(int, int = 5);         // error: cannot redefine, even to same value
 }
 void n() {
   f(6);                         // OK, calls f(6, 7)
 }
+template<class ... T> struct C {
+  void f(int n = 0, T...);
+};
+C<int> c;                       // OK, instantiates declaration void C::f(int n = 0, int)
 ```
 — *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; no diagnostic is required. 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 template in the translation unit.
 The default argument has the same semantic constraints as the
 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]].
 [*Example 3*:
 In the following code, `g` will be called with the value `f(2)`:
 }
 ```
 — *end example*]
+[*Note 3*: 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
 [[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
+ill-formed if a default constructor [[class.default.ctor]], copy or move
+constructor [[class.copy.ctor]], or copy or move assignment operator
+[[class.copy.assign]] 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 C::g(int i = 88, int j) {} // in this translation unit, C::g can be called with no argument
 ```
 — *end example*]
+[*Note 4*: A local variable cannot be odr-used [[basic.def.odr]] in a
+default argument. — *end note*]
 [*Example 5*:
 ``` cpp
 void f() {
 }
 ```
 — *end example*]
+[*Note 5*:
 The keyword `this` may not appear in a default argument of a member
 function; see  [[expr.prim.this]].
 [*Example 6*:
 ```
 — *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
 };
 ```
 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 [[class]].
 — *end example*]
 A default argument is not part of the type of a function.
 ```
 — *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
 following the redeclaration where the *using-declaration* is in scope.
+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.
 [*Example 10*:
 ``` cpp
 struct A {
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa