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

Files changed (1) hide show

tmp/tmpkppd7vkf/{from.md → to.md} +335 -237

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

@@ -1,17 +1,17 @@
-## 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*.
@@ -22,14 +22,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
@@ -55,11 +56,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`”.
@@ -78,11 +79,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'
@@ -90,12 +91,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
@@ -148,14 +149,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'
@@ -166,18 +167,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`”.
@@ -241,19 +242,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
@@ -261,15 +262,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*:
@@ -293,11 +293,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'
@@ -306,11 +306,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
@@ -341,102 +341,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];
@@ -451,102 +456,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
@@ -572,17 +581,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
@@ -597,31 +607,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*]
@@ -631,20 +638,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
 ```
@@ -670,11 +677,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*]
@@ -685,48 +693,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
@@ -791,23 +803,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);
@@ -823,17 +912,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
@@ -853,27 +944,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
@@ -892,28 +986,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)`:
@@ -932,24 +1030,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 {
@@ -961,12 +1059,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() {
@@ -977,11 +1075,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*:
@@ -1013,13 +1111,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
@@ -1035,11 +1133,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.
@@ -1058,21 +1156,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 {

+### 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 {

Diff to HTML by rtfpessoa