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

Files changed (1) hide show

tmp/tmpvislfbtk/{from.md → to.md} +368 -212

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

@@ -1,67 +1,75 @@
 ## Meaning of declarators <a id="dcl.meaning">[[dcl.meaning]]</a>
-A list of declarators appears after an optional (Clause  [[dcl.dcl]])
-*decl-specifier-seq* ([[dcl.spec]]). Each declarator contains exactly
-one *declarator-id*; it names the identifier that is declared. An
-*unqualified-id* occurring in a *declarator-id* shall be a simple
-*identifier* except for the declaration of some special functions (
-[[class.ctor]], [[class.conv]], [[class.dtor]], [[over.oper]]) and for
-the declaration of template specializations or partial specializations (
-[[temp.spec]]). When the *declarator-id* is qualified, the declaration
-shall refer to a previously declared member of the class or namespace to
-which the qualifier refers (or, in the case of a namespace, of an
-element of the inline namespace set of that namespace (
-[[namespace.def]])) or to a specialization thereof; the member shall not
-merely have been introduced by a *using-declaration* in the scope of the
-class or namespace nominated by the *nested-name-specifier* of the
-*declarator-id*. The *nested-name-specifier* of a qualified
-*declarator-id* shall not begin with a *decltype-specifier*. If the
-qualifier is the global `::` scope resolution operator, the
-*declarator-id* refers to a name declared in the global namespace scope.
 The optional *attribute-specifier-seq* following a *declarator-id*
 appertains to the entity that is declared.
-A `static`, `thread_local`, `extern`, `register`, `mutable`, `friend`,
-`inline`, `virtual`, or `typedef` specifier applies directly to each
-*declarator-id* in an *init-declarator-list*; the type specified for
-each *declarator-id* depends on both the *decl-specifier-seq* and its
-*declarator*.
 Thus, a declaration of a particular identifier has the form
 ``` cpp
 T D
 ```
-where `T` is of the form *attribute-specifier-seqₒₚₜ*
 *decl-specifier-seq* and `D` is a declarator. Following is a recursive
 procedure for determining the type specified for the contained
 *declarator-id* by such a declaration.
 First, the *decl-specifier-seq* determines a type. In a declaration
 ``` cpp
 T D
 ```
-the *decl-specifier-seq* `T` determines the type `T`. in the declaration
 ``` cpp
 int unsigned i;
 ```
 the type specifiers `int` `unsigned` determine the type “`unsigned int`”
 ([[dcl.type.simple]]).
-In a declaration *attribute-specifier-seqₒₚₜ* `T` `D` where `D` is an
 unadorned identifier the type of this identifier is “`T`”.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
-( D1 )
 ```
 the type of the contained *declarator-id* is the same as that of the
 contained *declarator-id* in the declaration
@@ -78,18 +86,21 @@ In a declaration `T` `D` where `D` has the form
 ``` bnf
 '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
-and the type of the identifier in the declaration `T` `D1` is “ `T`,”
-then the type of the identifier of `D` is “ pointer to `T`.” The
-*cv-qualifier*s apply to the pointer and not to the object pointed to.
-Similarly, the optional *attribute-specifier-seq* (
 [[dcl.attr.grammar]]) appertains to the pointer and not to the object
 pointed to.
-the declarations
 ``` cpp
 const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
 int i, *p, *const cp = &i;
 ```
@@ -126,56 +137,68 @@ ppc = &p;           // error
 Each is unacceptable because it would either change the value of an
 object declared `const` or allow it to be changed through a
 cv-unqualified pointer later, for example:
 ``` cpp
-*ppc = &ci;         // OK, but would make p point to ci ...
-                    // ... because of previous error
 *p = 5;             // clobber ci
 ```
 See also  [[expr.ass]] and  [[dcl.init]].
-Forming a pointer to reference type is ill-formed; see  [[dcl.ref]].
-Forming a pointer to function type is ill-formed if the function type
-has *cv-qualifier*s or a *ref-qualifier*; see  [[dcl.fct]]. Since the
-address of a bit-field ([[class.bit]]) cannot be taken, a pointer can
-never point to a bit-field.
 ### References <a id="dcl.ref">[[dcl.ref]]</a>
 In a declaration `T` `D` where `D` has either of the forms
 ``` bnf
 '&' attribute-specifier-seqₒₚₜ 'D1'
 '&&' attribute-specifier-seqₒₚₜ 'D1'
 ```
-and the type of the identifier in the declaration `T` `D1` is “ `T`,”
-then the type of the identifier of `D` is “ reference to `T`.” The
-optional *attribute-specifier-seq* appertains to the reference type.
-Cv-qualified references are ill-formed except when the cv-qualifiers are
-introduced through the use of a *typedef-name* ([[dcl.typedef]],
-[[temp.param]]) or *decltype-specifier* ([[dcl.type.simple]]), in which
-case the cv-qualifiers are ignored.
 ``` cpp
 typedef int& A;
 const A aref = 3;   // ill-formed; lvalue reference to non-const initialized with rvalue
 ```
 The type of `aref` is “lvalue reference to `int`”, not “lvalue reference
-to `const int`”. A reference can be thought of as a name of an object. A
-declarator that specifies the type “reference to *cv* `void`” is
 ill-formed.
 A reference type that is declared using `&` is called an *lvalue
 reference*, and a reference type that is declared using `&&` is called
 an *rvalue reference*. Lvalue references and rvalue references are
 distinct types. Except where explicitly noted, they are semantically
 equivalent and commonly referred to as references.
 ``` cpp
 void f(double& a) { a += 3.14; }
 // ...
 double d = 0;
 f(d);
@@ -216,33 +239,42 @@ void k() {
 ```
 declares `p` to be a reference to a pointer to `link` so `h(q)` will
 leave `q` with the value zero. See also  [[dcl.init.ref]].
 It is unspecified whether or not a reference requires storage (
 [[basic.stc]]).
 There shall be no references to references, no arrays of references, and
 no pointers to references. The declaration of a reference shall contain
 an *initializer* ([[dcl.init.ref]]) except when the declaration
 contains an explicit `extern` specifier ([[dcl.stc]]), is a class
 member ([[class.mem]]) declaration within a class definition, or is the
 declaration of a parameter or a return type ([[dcl.fct]]); see
 [[basic.def]]. A reference shall be initialized to refer to a valid
-object or function. in particular, a null reference cannot exist in a
 well-defined program, because the only way to create such a reference
 would be to bind it to the “object” obtained by indirection through a
 null pointer, which causes undefined behavior. As described in
-[[class.bit]], a reference cannot be bound directly to a bit-field.
 If a *typedef-name* ([[dcl.typedef]], [[temp.param]]) or a
 *decltype-specifier* ([[dcl.type.simple]]) denotes a type `TR` that is
 a reference to a type `T`, an attempt to create the type “lvalue
 reference to cv `TR`” creates the type “lvalue reference to `T`”, while
 an attempt to create the type “rvalue reference to cv `TR`” creates the
 type `TR`.
 ``` cpp
 int i;
 typedef int& LRI;
 typedef int&& RRI;
@@ -255,26 +287,33 @@ RRI&& r5 = 5;                   // r5 has the type int&&
 decltype(r2)& r6 = i;           // r6 has the type int&
 decltype(r2)&& r7 = i;          // r7 has the type int&
 ```
-Forming a reference to function type is ill-formed if the function type
-has *cv-qualifier*s or a *ref-qualifier*; see  [[dcl.fct]].
 ### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
-nested-name-specifier '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ D1
 ```
 and the *nested-name-specifier* denotes a class, and the type of the
-identifier in the declaration `T` `D1` is “ `T`”, then the type of the
-identifier of `D` is “ pointer to member of class of type `T`”. The
-optional *attribute-specifier-seq* ([[dcl.attr.grammar]]) appertains to
-the pointer-to-member.
 ``` cpp
 struct X {
   void f(int);
   int a;
@@ -296,24 +335,24 @@ declaration of `pmc` is well-formed even though `Y` is an incomplete
 type. `pmi` and `pmf` can be used like this:
 ``` cpp
 X obj;
 // ...
-obj.*pmi = 7;       // assign 7 to an integer
- // member of obj
-(obj.*pmf)(7);      // call a function member of obj
-                    // with the argument 7
 ```
 A pointer to member shall not point to a static member of a class (
-[[class.static]]), a member with reference type, or “*cv* `void`.”
-See also  [[expr.unary]] and  [[expr.mptr.oper]]. The type “pointer to
-member” is distinct from the type “pointer”, that is, a pointer to
-member is declared only by the pointer to member declarator syntax, and
-never by the pointer declarator syntax. There is no
-“reference-to-member” type in C++.
 ### Arrays <a id="dcl.array">[[dcl.array]]</a>
 In a declaration `T` `D` where `D` has the form
@@ -322,56 +361,65 @@ In a declaration `T` `D` where `D` has the form
 ```
 and the type of the identifier in the declaration `T` `D1` is
 “*derived-declarator-type-list* `T`”, then the type of the identifier of
 `D` is an array type; if the type of the identifier of `D` contains the
-`auto` , the program is ill-formed. `T` is called the array *element
-type*; this type shall not be a reference type, the (possibly
-cv-qualified) type `void`, a function type or an abstract class type. If
-the *constant-expression* ([[expr.const]]) is present, it shall be a
 converted constant expression of type `std::size_t` and its value shall
 be greater than zero. The constant expression specifies the *bound* of
 (number of elements in) the array. If the value of the constant
 expression is `N`, the array has `N` elements numbered `0` to `N-1`, and
-the type of the identifier of `D` is “ array of `N` `T`”. An object of
-array type contains a contiguously allocated non-empty set of `N`
-subobjects of type `T`. Except as noted below, if the constant
-expression is omitted, the type of the identifier of `D` is “ array of
-unknown bound of `T`”, an incomplete object type. The type “ array of
-`N` `T`” is a different type from the type “ array of unknown bound of
-`T`”, see  [[basic.types]]. Any type of the form “ array of `N` `T`” is
-adjusted to “array of `N` `T`”, and similarly for “array of unknown
-bound of `T`”. The optional *attribute-specifier-seq* appertains to the
-array.
 ``` cpp
 typedef int A[5], AA[2][3];
 typedef const A CA;             // type is ``array of 5 const int''
 typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
 ```
-An “array of `N` `T`” has cv-qualified type; see
-[[basic.type.qualifier]].
 An array can be constructed from one of the fundamental types (except
 `void`), from a pointer, from a pointer to member, from a class, from an
 enumeration type, or from another array.
 When several “array of” specifications are adjacent, a multidimensional
-array is created; only the first of the constant expressions that
 specify the bounds of the arrays may be omitted. In addition to
 declarations in which an incomplete object type is allowed, an array
 bound may be omitted in some cases in the declaration of a function
 parameter ([[dcl.fct]]). An array bound may also be omitted when the
-declarator is followed by an *initializer* ([[dcl.init]]). In this case
-the bound is calculated from the number of initial elements (say, `N`)
-supplied ([[dcl.init.aggr]]), and the type of the identifier of `D` is
-“array of `N` `T`.” Furthermore, if there is a preceding declaration of
-the entity in the same scope in which the bound was specified, an
-omitted array bound is taken to be the same as in that earlier
-declaration, and similarly for the definition of a static data member of
-a class.
 ``` cpp
 float fa[17], *afp[17];
 ```
@@ -401,31 +449,38 @@ void f() {
   extern int x[];
   int i = sizeof(x);    // error: incomplete object type
 }
 ```
-conversions affecting expressions of array type are described in
-[[conv.array]]. Objects of array types cannot be modified, see
-[[basic.lval]].
-Except where it has been declared for a class ([[over.sub]]), the
-subscript operator `[]` is interpreted in such a way that `E1[E2]` is
-identical to `*((E1)+(E2))`. Because of the conversion rules that apply
-to `+`, if `E1` is an array and `E2` an integer, then `E1[E2]` refers to
-the `E2`-th member of `E1`. Therefore, despite its asymmetric
-appearance, subscripting is a commutative operation.
 A consistent rule is followed for multidimensional arrays. If `E` is an
 *n*-dimensional array of rank i × j × … × k, then `E` appearing in an
 expression that is subject to the array-to-pointer conversion (
 [[conv.array]]) is converted to a pointer to an (n-1)-dimensional array
 with rank j × … × k. If the `*` operator, either explicitly or
 implicitly as a result of subscripting, is applied to this pointer, the
 result is the pointed-to (n-1)-dimensional array, which itself is
 immediately converted into a pointer.
-consider
 ``` cpp
 int x[3][5];
 ```
@@ -438,50 +493,60 @@ multiplying `i` by the length of the object to which the pointer points,
 namely five integer objects. The results are added and indirection
 applied to yield an array (of five integers), which in turn is converted
 to a pointer to the first of the integers. If there is another subscript
 the same argument applies again; this time the result is an integer.
-It follows from all this that arrays in C++are stored row-wise (last
-subscript varies fastest) and that the first subscript in the
-declaration helps determine the amount of storage consumed by an array
-but plays no other part in subscript calculations.
 ### Functions <a id="dcl.fct">[[dcl.fct]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, the type of the
-*declarator-id* in `D` is “ function of ( ) returning `T`”. The optional
-*attribute-specifier-seq* appertains to the function type.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-type
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, `T` shall be the single
 *type-specifier* `auto`. The type of the *declarator-id* in `D` is
-“*derived-declarator-type-list* function of
-(*parameter-declaration-clause*) *cv-qualifier-seq*
-*ref-qualifier*returning *trailing-return-type*”. The optional
 *attribute-specifier-seq* appertains to the function type.
-A type of either form is a *function type*.[^9]
 ``` bnf
 parameter-declaration-clause:
-    parameter-declaration-listₒₚₜ ...ₒₚₜ
-    parameter-declaration-list ',' ...
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
@@ -498,23 +563,30 @@ parameter-declaration:
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
 The *parameter-declaration-clause* determines the arguments that can be
-specified, and their processing, when the function is called. the
-*parameter-declaration-clause* is used to convert the arguments
-specified on the function call; see  [[expr.call]]. If the
-*parameter-declaration-clause* is empty, the function takes no
 arguments. A parameter list consisting of a single unnamed parameter of
 non-dependent type `void` is equivalent to an empty parameter list.
 Except for this special case, a parameter shall not have type *cv*
 `void`. If the *parameter-declaration-clause* terminates with an
 ellipsis or a function parameter pack ([[temp.variadic]]), the number
 of arguments shall be equal to or greater than the number of parameters
 that do not have a default argument and are not function parameter
-packs. Where syntactically correct and where “” is not part of an
-*abstract-declarator*, “” is synonymous with “”. the declaration
 ``` cpp
 int printf(const char*, ...);
 ```
@@ -525,31 +597,35 @@ arguments.
 printf("hello world");
 printf("a=%d b=%d", a, b);
 ```
 However, the first argument must be of a type that can be converted to a
-`const` `char*` The standard header `<cstdarg>` contains a mechanism for
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
-[[support.runtime]]).
 A single name can be used for several different functions in a single
 scope; this is function overloading (Clause  [[over]]). All declarations
 for a function shall agree exactly in both the return type and the
 parameter-type-list. The type of a function is determined using the
 following rules. The type of each parameter (including function
 parameter packs) is determined from its own *decl-specifier-seq* and
 *declarator*. After determining the type of each parameter, any
-parameter of type “array of `T`” or “function returning `T`” is adjusted
-to be “pointer to `T`” or “pointer to function returning `T`,”
-respectively. After producing the list of parameter types, any top-level
-*cv-qualifier*s modifying a parameter type are deleted when forming the
-function type. The resulting list of transformed parameter types and the
-presence or absence of the ellipsis or a function parameter pack is the
-function’s *parameter-type-list*. This transformation does not affect
-the types of the parameters. For example,
-`int(*)(const int p, decltype(p)*)` and `int(*)(int, const int*)` are
-identical types.
 A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 (including a type named by *typedef-name* ([[dcl.typedef]],
 [[temp.param]])) shall appear only as:
@@ -560,82 +636,101 @@ A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 - the *type-id* in the default argument of a *type-parameter* (
   [[temp.param]]), or
 - the *type-id* of a *template-argument* for a *type-parameter* (
   [[temp.arg.type]]).
 ``` cpp
 typedef int FIC(int) const;
 FIC f;              // ill-formed: does not declare a member function
 struct S {
   FIC f;            // OK
 };
 FIC S::*pm = &S::f; // OK
 ```
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 same as adding cv-qualification on top of the function type. In the
-latter case, the cv-qualifiers are ignored. a function type that has a
-*cv-qualifier-seq* is not a cv-qualified type; there are no cv-qualified
-function types.
 ``` cpp
 typedef void F();
 struct S {
   const F f;        // OK: equivalent to: void f();
 };
 ```
-The return type, the parameter-type-list, the *ref-qualifier*, and the
-*cv-qualifier-seq*, but not the default arguments ([[dcl.fct.default]])
-or the exception specification ([[except.spec]]), are part of the
-function type. Function types are checked during the assignments and
 initializations of pointers to functions, references to functions, and
-pointers to member functions.
-the declaration
 ``` cpp
 int fseek(FILE*, long, int);
 ```
 declares a function taking three arguments of the specified types, and
 returning `int` ([[dcl.type]]).
-If the type of a parameter includes a type of the form “pointer to array
-of unknown bound of `T`” or “reference to array of unknown bound of
-`T`,” the program is ill-formed.[^10] Functions shall not have a return
-type of type array or function, although they may have a return type of
-type pointer or reference to such things. There shall be no arrays of
-functions, although there can be arrays of pointers to functions.
 Types shall not be defined in return or parameter types. The type of a
 parameter or the return type for a function definition shall not be an
-incomplete class type (possibly cv-qualified) unless the function is
-deleted ([[dcl.fct.def.delete]]) or the definition is nested within the
-*member-specification* for that class (including definitions in nested
-classes defined within the class).
 A typedef of function type may be used to declare a function but shall
 not be used to define a function ([[dcl.fct.def]]).
 ``` cpp
 typedef void F();
 F  fv;              // OK: equivalent to void fv();
 F  fv { }           // ill-formed
 void fv() { }       // OK: definition of fv
 ```
 An identifier can optionally be provided as a parameter name; if present
-in a function definition ([[dcl.fct.def]]), it names a parameter. In
-particular, parameter names are also optional in function definitions
-and names used for a parameter in different declarations and the
-definition of a function need not be the same. If a parameter name is
-present in a function declaration that is not a definition, it cannot be
-used outside of its function declarator because that is the extent of
-its potential scope ([[basic.scope.proto]]).
-the declaration
 ``` cpp
 int i,
     *pi,
     f(),
@@ -655,13 +750,19 @@ The binding of `*fpi(int)` is `*(fpi(int))`, so the declaration
 suggests, and the same construction in an expression requires, the
 calling of a function `fpi`, and then using indirection through the
 (pointer) result to yield an integer. In the declarator
 `(*pif)(const char*, const char*)`, the extra parentheses are necessary
 to indicate that indirection through a pointer to a function yields a
-function, which is then called. Typedefs and *trailing-return-type*s are
-sometimes convenient when the return type of a function is complex. For
-example, the function `fpif` above could have been declared
 ``` cpp
 typedef int  IFUNC(int);
 IFUNC*  fpif(int);
 ```
@@ -683,21 +784,30 @@ rather than
 ``` cpp
 template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);
 ```
 A *non-template function* is a function that is not a function template
-specialization. A function template is not a function.
 A *declarator-id* or *abstract-declarator* containing an ellipsis shall
 only be used in a *parameter-declaration*. Such a
 *parameter-declaration* is a parameter pack ([[temp.variadic]]). When
 it is part of a *parameter-declaration-clause*, the parameter pack is a
-function parameter pack ([[temp.variadic]]). Otherwise, the
-*parameter-declaration* is part of a *template-parameter-list* and the
-parameter pack is a template parameter pack; see  [[temp.param]]. A
-function parameter pack is a pack expansion ([[temp.variadic]]).
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
@@ -706,24 +816,28 @@ float subtract(int, int);
 void g() {
   f(add, subtract);
 }
 ```
 There is a syntactic ambiguity when an ellipsis occurs at the end of a
 *parameter-declaration-clause* without a preceding comma. In this case,
 the ellipsis is parsed as part of the *abstract-declarator* if the type
 of the parameter either names a template parameter pack that has not
 been expanded or contains `auto`; otherwise, it is parsed as part of the
-*parameter-declaration-clause*.[^11]
 ### Default arguments <a id="dcl.fct.default">[[dcl.fct.default]]</a>
 If an *initializer-clause* is specified in a *parameter-declaration*
 this *initializer-clause* is used as a default argument. Default
 arguments will be used in calls where trailing arguments are missing.
-the declaration
 ``` cpp
 void point(int = 3, int = 4);
 ```
@@ -735,17 +849,20 @@ point(1,2);  point(1);  point();
 ```
 The last two calls are equivalent to `point(1,4)` and `point(3,4)`,
 respectively.
 A default argument shall be specified only in the
-*parameter-declaration-clause* of a function declaration or in a
-*template-parameter* ([[temp.param]]); in the latter case, the
-*initializer-clause* shall be an *assignment-expression*. A default
-argument shall not be specified for a parameter pack. If it is specified
-in a *parameter-declaration-clause*, it shall not occur within a
-*declarator* or *abstract-declarator* of a *parameter-declaration*.[^12]
 For non-template functions, default arguments can be added in later
 declarations of a function in the same scope. Declarations in different
 scopes have completely distinct sets of default arguments. That is,
 declarations in inner scopes do not acquire default arguments from
@@ -754,33 +871,35 @@ declaration, each parameter subsequent to a parameter with a default
 argument shall have a default argument supplied in this or a previous
 declaration or shall be a function parameter pack. A default argument
 shall not be redefined by a later declaration (not even to the same
 value).
 ``` cpp
 void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
                                 // a parameter with a default argument
 void f(int, int);
 void f(int, int = 7);
 void h() {
   f(3);                         // OK, calls f(3, 7)
-  void f(int = 1, int);         // error: does not use default
-                                // from surrounding scope
 }
 void m() {
   void f(int, int);             // has no defaults
   f(4);                         // error: wrong number of arguments
   void f(int, int = 5);         // OK
   f(4);                         // OK, calls f(4, 5);
-  void f(int, int = 5);         // error: cannot redefine, even to
-                                // same value
 }
 void n() {
   f(6);                         // OK, calls f(6, 7)
 }
 ```
 For a given inline function defined in different translation units, the
 accumulated sets of default arguments at the end of the translation
 units shall be the same; see  [[basic.def.odr]]. If a friend declaration
 specifies a default argument expression, that declaration shall be a
 definition and shall be the only declaration of the function or function
@@ -791,12 +910,15 @@ initializer in a declaration of a variable of the parameter type, using
 the copy-initialization semantics ([[dcl.init]]). The names in the
 default argument are bound, and the semantic constraints are checked, at
 the point where the default argument appears. Name lookup and checking
 of semantic constraints for default arguments in function templates and
 in member functions of class templates are performed as described in
-[[temp.inst]]. in the following code, `g` will be called with the value
-`f(2)`:
 ``` cpp
 int a = 1;
 int f(int);
 int g(int x = f(a));            // default argument: f(::a)
@@ -808,13 +930,16 @@ void h() {
   g();                          // g(f(::a))
   }
 }
 ```
-In member function declarations, names in default arguments are looked
-up as described in  [[basic.lookup.unqual]]. Access checking applies to
-names in default arguments as described in Clause  [[class.access]].
 Except for member functions of class templates, the default arguments in
 a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
@@ -822,80 +947,105 @@ ill-formed if a default constructor ([[class.ctor]]), copy or move
 constructor, or copy or move assignment operator ([[class.copy]]) is so
 declared. Default arguments for a member function of a class template
 shall be specified on the initial declaration of the member function
 within the class template.
 ``` cpp
 class C {
   void f(int i = 3);
   void g(int i, int j = 99);
 };
-void C::f(int i = 3) { // error: default argument already
-} // specified in class scope
-void C::g(int i = 88, int j) {  // in this translation unit,
-}                               // C::g can be called with no argument
 ```
-Local variables shall not be used in a default argument.
 ``` cpp
 void f() {
   int i;
   extern void g(int x = i);         // error
   // ...
 }
 ```
-The keyword `this` shall not be used in a default argument of a member
-function.
 ``` cpp
 class A {
   void f(A* p = this) { }           // error
 };
 ```
 A default argument is evaluated each time the function is called with no
-argument for the corresponding parameter. The order of evaluation of
-function arguments is unspecified. Consequently, parameters of a
-function shall not be used in a default argument, even if they are not
-evaluated. Parameters of a function declared before a default argument
-are in scope and can hide namespace and class member names.
 ``` cpp
 int a;
-int f(int a, int b = a);            // error: parameter a
-                                    // used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter I found
-int h(int a, int b = sizeof(a));    // error, parameter a used
-                                    // in default argument
 ```
-Similarly, a non-static member shall not be used in a default argument,
-even if it is not evaluated, unless it appears as the *id-expression* of
-a class member access expression ([[expr.ref]]) or unless it is used to
-form a pointer to member ([[expr.unary.op]]). the declaration of
-`X::mem1()` in the following example is ill-formed because no object is
-supplied for the non-static member `X::a` used as an initializer.
 ``` cpp
 int b;
 class X {
   int a;
-  int mem1(int i = a); // error: non-static member a
-                                // used as default argument
   int mem2(int i = b);              // OK;  use X::b
   static int b;
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
 is needed to access the static member `X::b`. Classes, objects, and
-members are described in Clause  [[class]]. A default argument is not
-part of the type of a function.
 ``` cpp
 int f(int = 0);
 void h() {
@@ -905,10 +1055,12 @@ void h() {
 int (*p1)(int) = &f;
 int (*p2)() = &f;                   // error: type mismatch
 ```
 When a declaration of a function is introduced by way of a
 *using-declaration* ([[namespace.udecl]]), any default argument
 information associated with the declaration is made known as well. If
 the function is redeclared thereafter in the namespace with additional
 default arguments, the additional arguments are also known at any point
@@ -918,10 +1070,12 @@ A virtual function call ([[class.virtual]]) uses the default arguments
 in the declaration of the virtual function determined by the static type
 of the pointer or reference denoting the object. An overriding function
 in a derived class does not acquire default arguments from the function
 it overrides.
 ``` cpp
 struct A {
   virtual void f(int a = 7);
 };
 struct B : public A {
@@ -933,5 +1087,7 @@ void m() {
   pa->f();          // OK, calls pa->B::f(7)
   pb->f();          // error: wrong number of arguments for B::f()
 }
 ```

 ## Meaning of declarators <a id="dcl.meaning">[[dcl.meaning]]</a>
+A declarator contains exactly one *declarator-id*; it names the
+identifier that is declared. An *unqualified-id* occurring in a
+*declarator-id* shall be a simple *identifier* except for the
+declaration of some special functions ([[class.ctor]], [[class.conv]],
+[[class.dtor]], [[over.oper]]) and for the declaration of template
+specializations or partial specializations ([[temp.spec]]). When the
+*declarator-id* is qualified, the declaration shall refer to a
+previously declared member of the class or namespace to which the
+qualifier refers (or, in the case of a namespace, of an element of the
+inline namespace set of that namespace ([[namespace.def]])) or to a
+specialization thereof; the member shall not merely have been introduced
+by a *using-declaration* in the scope of the class or namespace
+nominated by the *nested-name-specifier* of the *declarator-id*. The
+*nested-name-specifier* of a qualified *declarator-id* shall not begin
+with a *decltype-specifier*.
+[*Note 1*: If the qualifier is the global `::` scope resolution
+operator, the *declarator-id* refers to a name declared in the global
+namespace scope. — *end note*]
 The optional *attribute-specifier-seq* following a *declarator-id*
 appertains to the entity that is declared.
+A `static`, `thread_local`, `extern`, `mutable`, `friend`, `inline`,
+`virtual`, `constexpr`, `explicit`, or `typedef` specifier applies
+directly to each *declarator-id* in an *init-declarator-list* or
+*member-declarator-list*; the type specified for each *declarator-id*
+depends on both the *decl-specifier-seq* and its *declarator*.
 Thus, a declaration of a particular identifier has the form
 ``` cpp
 T D
 ```
+where `T` is of the form *attribute-specifier-seq*ₒₚₜ
 *decl-specifier-seq* and `D` is a declarator. Following is a recursive
 procedure for determining the type specified for the contained
 *declarator-id* by such a declaration.
 First, the *decl-specifier-seq* determines a type. In a declaration
 ``` cpp
 T D
 ```
+the *decl-specifier-seq* `T` determines the type `T`.
+[*Example 1*:
+In the declaration
 ``` cpp
 int unsigned i;
 ```
 the type specifiers `int` `unsigned` determine the type “`unsigned int`”
 ([[dcl.type.simple]]).
+— *end example*]
+In a declaration *attribute-specifier-seq*ₒₚₜ  `T` `D` where `D` is an
 unadorned identifier the type of this identifier is “`T`”.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
+'(' 'D1' ')'
 ```
 the type of the contained *declarator-id* is the same as that of the
 contained *declarator-id* in the declaration
 ``` bnf
 '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
+and the type of the identifier in the declaration `T` `D1` is
+“*derived-declarator-type-list* `T`”, then the type of the identifier of
+`D` is “*derived-declarator-type-list* *cv-qualifier-seq* pointer to
+`T`”. The *cv-qualifier*s apply to the pointer and not to the object
+pointed to. Similarly, the optional *attribute-specifier-seq* (
 [[dcl.attr.grammar]]) appertains to the pointer and not to the object
 pointed to.
+[*Example 1*:
+The declarations
 ``` cpp
 const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
 int i, *p, *const cp = &i;
 ```
 Each is unacceptable because it would either change the value of an
 object declared `const` or allow it to be changed through a
 cv-unqualified pointer later, for example:
 ``` cpp
+*ppc = &ci;         // OK, but would make p point to ci because of previous error
 *p = 5;             // clobber ci
 ```
+— *end example*]
 See also  [[expr.ass]] and  [[dcl.init]].
+[*Note 1*: Forming a pointer to reference type is ill-formed; see
+[[dcl.ref]]. Forming a function pointer type is ill-formed if the
+function type has *cv-qualifier*s or a *ref-qualifier*; see
+[[dcl.fct]]. Since the address of a bit-field ([[class.bit]]) cannot be
+taken, a pointer can never point to a bit-field. — *end note*]
 ### References <a id="dcl.ref">[[dcl.ref]]</a>
 In a declaration `T` `D` where `D` has either of the forms
 ``` bnf
 '&' attribute-specifier-seqₒₚₜ 'D1'
 '&&' attribute-specifier-seqₒₚₜ 'D1'
 ```
+and the type of the identifier in the declaration `T` `D1` is
+“*derived-declarator-type-list* `T`”, then the type of the identifier of
+`D` is “*derived-declarator-type-list* reference to `T`”. The optional
+*attribute-specifier-seq* appertains to the reference type. Cv-qualified
+references are ill-formed except when the cv-qualifiers are introduced
+through the use of a *typedef-name* ([[dcl.typedef]], [[temp.param]])
+or *decltype-specifier* ([[dcl.type.simple]]), in which case the
+cv-qualifiers are ignored.
+[*Example 1*:
 ``` cpp
 typedef int& A;
 const A aref = 3;   // ill-formed; lvalue reference to non-const initialized with rvalue
 ```
 The type of `aref` is “lvalue reference to `int`”, not “lvalue reference
+to `const int`”.
+— *end example*]
+[*Note 1*: A reference can be thought of as a name of an
+object. — *end note*]
+A declarator that specifies the type “reference to cv `void`” is
 ill-formed.
 A reference type that is declared using `&` is called an *lvalue
 reference*, and a reference type that is declared using `&&` is called
 an *rvalue reference*. Lvalue references and rvalue references are
 distinct types. Except where explicitly noted, they are semantically
 equivalent and commonly referred to as references.
+[*Example 2*:
 ``` cpp
 void f(double& a) { a += 3.14; }
 // ...
 double d = 0;
 f(d);
 ```
 declares `p` to be a reference to a pointer to `link` so `h(q)` will
 leave `q` with the value zero. See also  [[dcl.init.ref]].
+— *end example*]
 It is unspecified whether or not a reference requires storage (
 [[basic.stc]]).
 There shall be no references to references, no arrays of references, and
 no pointers to references. The declaration of a reference shall contain
 an *initializer* ([[dcl.init.ref]]) except when the declaration
 contains an explicit `extern` specifier ([[dcl.stc]]), is a class
 member ([[class.mem]]) declaration within a class definition, or is the
 declaration of a parameter or a return type ([[dcl.fct]]); see
 [[basic.def]]. A reference shall be initialized to refer to a valid
+object or function.
+[*Note 2*:  In particular, a null reference cannot exist in a
 well-defined program, because the only way to create such a reference
 would be to bind it to the “object” obtained by indirection through a
 null pointer, which causes undefined behavior. As described in
+[[class.bit]], a reference cannot be bound directly to a
+bit-field. — *end note*]
 If a *typedef-name* ([[dcl.typedef]], [[temp.param]]) or a
 *decltype-specifier* ([[dcl.type.simple]]) denotes a type `TR` that is
 a reference to a type `T`, an attempt to create the type “lvalue
 reference to cv `TR`” creates the type “lvalue reference to `T`”, while
 an attempt to create the type “rvalue reference to cv `TR`” creates the
 type `TR`.
+[*Note 3*: This rule is known as reference collapsing. — *end note*]
+[*Example 3*:
 ``` cpp
 int i;
 typedef int& LRI;
 typedef int&& RRI;
 decltype(r2)& r6 = i;           // r6 has the type int&
 decltype(r2)&& r7 = i;          // r7 has the type int&
 ```
+— *end example*]
+[*Note 4*: Forming a reference to function type is ill-formed if the
+function type has *cv-qualifier*s or a *ref-qualifier*; see
+[[dcl.fct]]. — *end note*]
 ### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
+nested-name-specifier '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
 and the *nested-name-specifier* denotes a class, and the type of the
+identifier in the declaration `T` `D1` is
+“*derived-declarator-type-list* `T`”, then the type of the identifier of
+`D` is “*derived-declarator-type-list* *cv-qualifier-seq* pointer to
+member of class *nested-name-specifier* of type `T`”. The optional
+*attribute-specifier-seq* ([[dcl.attr.grammar]]) appertains to the
+pointer-to-member.
+[*Example 1*:
 ``` cpp
 struct X {
   void f(int);
   int a;
 type. `pmi` and `pmf` can be used like this:
 ``` cpp
 X obj;
 // ...
+obj.*pmi = 7;       // assign 7 to an integer member of obj
+(obj.*pmf)(7);      // call a function member of obj with the argument 7
 ```
+— *end example*]
 A pointer to member shall not point to a static member of a class (
+[[class.static]]), a member with reference type, or “cv `void`”.
+[*Note 1*: See also  [[expr.unary]] and  [[expr.mptr.oper]]. The type
+“pointer to member” is distinct from the type “pointer”, that is, a
+pointer to member is declared only by the pointer to member declarator
+syntax, and never by the pointer declarator syntax. There is no
+“reference-to-member” type in C++. — *end note*]
 ### Arrays <a id="dcl.array">[[dcl.array]]</a>
 In a declaration `T` `D` where `D` has the form
 ```
 and the type of the identifier in the declaration `T` `D1` is
 “*derived-declarator-type-list* `T`”, then the type of the identifier of
 `D` is an array type; if the type of the identifier of `D` contains the
+`auto` *type-specifier*, the program is ill-formed. `T` is called the
+array *element type*; this type shall not be a reference type,
+cv `void`, a function type or an abstract class type. If the
+*constant-expression* ([[expr.const]]) is present, it shall be a
 converted constant expression of type `std::size_t` and its value shall
 be greater than zero. The constant expression specifies the *bound* of
 (number of elements in) the array. If the value of the constant
 expression is `N`, the array has `N` elements numbered `0` to `N-1`, and
+the type of the identifier of `D` is “*derived-declarator-type-list*
+array of `N` `T`”. An object of array type contains a contiguously
+allocated non-empty set of `N` subobjects of type `T`. Except as noted
+below, if the constant expression is omitted, the type of the identifier
+of `D` is “*derived-declarator-type-list* array of unknown bound of
+`T`”, an incomplete object type. The type
+“*derived-declarator-type-list* array of `N` `T`” is a different type
+from the type “*derived-declarator-type-list* array of unknown bound of
+`T`”, see  [[basic.types]]. Any type of the form “*cv-qualifier-seq*
+array of `N` `T`” is adjusted to “array of `N` *cv-qualifier-seq* `T`”,
+and similarly for “array of unknown bound of `T`”. The optional
+*attribute-specifier-seq* appertains to the array.
+[*Example 1*:
 ``` cpp
 typedef int A[5], AA[2][3];
 typedef const A CA;             // type is ``array of 5 const int''
 typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
 ```
+— *end example*]
+[*Note 1*: An “array of `N` *cv-qualifier-seq* `T`” has cv-qualified
+type; see  [[basic.type.qualifier]]. — *end note*]
 An array can be constructed from one of the fundamental types (except
 `void`), from a pointer, from a pointer to member, from a class, from an
 enumeration type, or from another array.
 When several “array of” specifications are adjacent, a multidimensional
+array type is created; only the first of the constant expressions that
 specify the bounds of the arrays may be omitted. In addition to
 declarations in which an incomplete object type is allowed, an array
 bound may be omitted in some cases in the declaration of a function
 parameter ([[dcl.fct]]). An array bound may also be omitted when the
+declarator is followed by an *initializer* ([[dcl.init]]) or when a
+declarator for a static data member is followed by a
+*brace-or-equal-initializer* ([[class.mem]]). In both cases the bound
+is calculated from the number of initial elements (say, `N`) supplied (
+[[dcl.init.aggr]]), and the type of the identifier of `D` is “array of
+`N` `T`”. Furthermore, if there is a preceding declaration of the entity
+in the same scope in which the bound was specified, an omitted array
+bound is taken to be the same as in that earlier declaration, and
+similarly for the definition of a static data member of a class.
+[*Example 2*:
 ``` cpp
 float fa[17], *afp[17];
 ```
   extern int x[];
   int i = sizeof(x);    // error: incomplete object type
 }
 ```
+— *end example*]
+[*Note 2*: Conversions affecting expressions of array type are
+described in  [[conv.array]]. Objects of array types cannot be modified,
+see  [[basic.lval]]. — *end note*]
+[*Note 3*: Except where it has been declared for a class (
+[[over.sub]]), the subscript operator `[]` is interpreted in such a way
+that `E1[E2]` is identical to `*((E1)+(E2))` ([[expr.sub]]). Because of
+the conversion rules that apply to `+`, if `E1` is an array and `E2` an
+integer, then `E1[E2]` refers to the `E2`-th member of `E1`. Therefore,
+despite its asymmetric appearance, subscripting is a commutative
+operation. — *end note*]
+[*Note 4*:
 A consistent rule is followed for multidimensional arrays. If `E` is an
 *n*-dimensional array of rank i × j × … × k, then `E` appearing in an
 expression that is subject to the array-to-pointer conversion (
 [[conv.array]]) is converted to a pointer to an (n-1)-dimensional array
 with rank j × … × k. If the `*` operator, either explicitly or
 implicitly as a result of subscripting, is applied to this pointer, the
 result is the pointed-to (n-1)-dimensional array, which itself is
 immediately converted into a pointer.
+[*Example 3*:
+Consider
 ``` cpp
 int x[3][5];
 ```
 namely five integer objects. The results are added and indirection
 applied to yield an array (of five integers), which in turn is converted
 to a pointer to the first of the integers. If there is another subscript
 the same argument applies again; this time the result is an integer.
+— *end example*]
+— *end note*]
+[*Note 5*: It follows from all this that arrays in C++are stored
+row-wise (last subscript varies fastest) and that the first subscript in
+the declaration helps determine the amount of storage consumed by an
+array but plays no other part in subscript calculations. — *end note*]
 ### Functions <a id="dcl.fct">[[dcl.fct]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
+  ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, the type of the
+*declarator-id* in `D` is “*derived-declarator-type-list* `noexcept`
+function of (*parameter-declaration-clause*) *cv-qualifier-seq*ₒₚₜ
+*ref-qualifier*ₒₚₜ  returning `T`”, where the optional `noexcept` is
+present if and only if the exception specification ([[except.spec]]) is
+non-throwing. The optional *attribute-specifier-seq* appertains to the
+function type.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
+  ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-type
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, `T` shall be the single
 *type-specifier* `auto`. The type of the *declarator-id* in `D` is
+“*derived-declarator-type-list* `noexcept` function of
+(*parameter-declaration-clause*) *cv-qualifier-seq**ref-qualifier*
+returning `U`”, where `U` is the type specified by the
+*trailing-return-type*, and where the optional `noexcept` is present if
+and only if the exception specification is non-throwing. The optional
 *attribute-specifier-seq* appertains to the function type.
+A type of either form is a *function type*.[^8]
 ``` bnf
 parameter-declaration-clause:
+    parameter-declaration-listₒₚₜ '...'ₒₚₜ
+    parameter-declaration-list ', ...'
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
 The *parameter-declaration-clause* determines the arguments that can be
+specified, and their processing, when the function is called.
+[*Note 1*:  The *parameter-declaration-clause* is used to convert the
+arguments specified on the function call; see
+[[expr.call]]. — *end note*]
+If the *parameter-declaration-clause* is empty, the function takes no
 arguments. A parameter list consisting of a single unnamed parameter of
 non-dependent type `void` is equivalent to an empty parameter list.
 Except for this special case, a parameter shall not have type *cv*
 `void`. If the *parameter-declaration-clause* terminates with an
 ellipsis or a function parameter pack ([[temp.variadic]]), the number
 of arguments shall be equal to or greater than the number of parameters
 that do not have a default argument and are not function parameter
+packs. Where syntactically correct and where “`...`” is not part of an
+*abstract-declarator*, “`, ...`” is synonymous with “`...`”.
+[*Example 1*:
+The declaration
 ``` cpp
 int printf(const char*, ...);
 ```
 printf("hello world");
 printf("a=%d b=%d", a, b);
 ```
 However, the first argument must be of a type that can be converted to a
+`const` `char*`
+— *end example*]
+[*Note 2*: The standard header `<cstdarg>` contains a mechanism for
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
+[[support.runtime]]). — *end note*]
 A single name can be used for several different functions in a single
 scope; this is function overloading (Clause  [[over]]). All declarations
 for a function shall agree exactly in both the return type and the
 parameter-type-list. The type of a function is determined using the
 following rules. The type of each parameter (including function
 parameter packs) is determined from its own *decl-specifier-seq* and
 *declarator*. After determining the type of each parameter, any
+parameter of type “array of `T`” or of function type `T` is adjusted to
+be “pointer to `T`”. After producing the list of parameter types, any
+top-level *cv-qualifier*s modifying a parameter type are deleted when
+forming the function type. The resulting list of transformed parameter
+types and the presence or absence of the ellipsis or a function
+parameter pack is the function’s *parameter-type-list*.
+[*Note 3*: This transformation does not affect the types of the
+parameters. For example, `int(*)(const int p, decltype(p)*)` and
+`int(*)(int, const int*)` are identical types. — *end note*]
 A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 (including a type named by *typedef-name* ([[dcl.typedef]],
 [[temp.param]])) shall appear only as:
 - the *type-id* in the default argument of a *type-parameter* (
   [[temp.param]]), or
 - the *type-id* of a *template-argument* for a *type-parameter* (
   [[temp.arg.type]]).
+[*Example 2*:
 ``` cpp
 typedef int FIC(int) const;
 FIC f;              // ill-formed: does not declare a member function
 struct S {
   FIC f;            // OK
 };
 FIC S::*pm = &S::f; // OK
 ```
+— *end example*]
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 same as adding cv-qualification on top of the function type. In the
+latter case, the cv-qualifiers are ignored.
+[*Note 4*: A function type that has a *cv-qualifier-seq* is not a
+cv-qualified type; there are no cv-qualified function
+types. — *end note*]
+[*Example 3*:
 ``` cpp
 typedef void F();
 struct S {
   const F f;        // OK: equivalent to: void f();
 };
 ```
+— *end example*]
+The return type, the parameter-type-list, the *ref-qualifier*, the
+*cv-qualifier-seq*, and the exception specification, but not the default
+arguments ([[dcl.fct.default]]), are part of the function type.
+[*Note 5*: Function types are checked during the assignments and
 initializations of pointers to functions, references to functions, and
+pointers to member functions. — *end note*]
+[*Example 4*:
+The declaration
 ``` cpp
 int fseek(FILE*, long, int);
 ```
 declares a function taking three arguments of the specified types, and
 returning `int` ([[dcl.type]]).
+— *end example*]
+Functions shall not have a return type of type array or function,
+although they may have a return type of type pointer or reference to
+such things. There shall be no arrays of functions, although there can
+be arrays of pointers to functions.
 Types shall not be defined in return or parameter types. The type of a
 parameter or the return type for a function definition shall not be an
+incomplete (possibly cv-qualified) class type in the context of the
+function definition unless the function is deleted (
+[[dcl.fct.def.delete]]).
 A typedef of function type may be used to declare a function but shall
 not be used to define a function ([[dcl.fct.def]]).
+[*Example 5*:
 ``` cpp
 typedef void F();
 F  fv;              // OK: equivalent to void fv();
 F  fv { }           // ill-formed
 void fv() { }       // OK: definition of fv
 ```
+— *end example*]
 An identifier can optionally be provided as a parameter name; if present
+in a function definition ([[dcl.fct.def]]), it names a parameter.
+[*Note 6*: In particular, parameter names are also optional in function
+definitions and names used for a parameter in different declarations and
+the definition of a function need not be the same. If a parameter name
+is present in a function declaration that is not a definition, it cannot
+be used outside of its function declarator because that is the extent of
+its potential scope ([[basic.scope.proto]]). — *end note*]
+[*Example 6*:
+The declaration
 ``` cpp
 int i,
     *pi,
     f(),
 suggests, and the same construction in an expression requires, the
 calling of a function `fpi`, and then using indirection through the
 (pointer) result to yield an integer. In the declarator
 `(*pif)(const char*, const char*)`, the extra parentheses are necessary
 to indicate that indirection through a pointer to a function yields a
+function, which is then called.
+— *end example*]
+[*Note 7*:
+Typedefs and *trailing-return-type*s are sometimes convenient when the
+return type of a function is complex. For example, the function `fpif`
+above could have been declared
 ``` cpp
 typedef int  IFUNC(int);
 IFUNC*  fpif(int);
 ```
 ``` cpp
 template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);
 ```
+— *end note*]
 A *non-template function* is a function that is not a function template
+specialization.
+[*Note 8*: A function template is not a function. — *end note*]
 A *declarator-id* or *abstract-declarator* containing an ellipsis shall
 only be used in a *parameter-declaration*. Such a
 *parameter-declaration* is a parameter pack ([[temp.variadic]]). When
 it is part of a *parameter-declaration-clause*, the parameter pack is a
+function parameter pack ([[temp.variadic]]).
+[*Note 9*: Otherwise, the *parameter-declaration* is part of a
+*template-parameter-list* and the parameter pack is a template parameter
+pack; see  [[temp.param]]. — *end note*]
+A function parameter pack is a pack expansion ([[temp.variadic]]).
+[*Example 7*:
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
 void g() {
   f(add, subtract);
 }
 ```
+— *end example*]
 There is a syntactic ambiguity when an ellipsis occurs at the end of a
 *parameter-declaration-clause* without a preceding comma. In this case,
 the ellipsis is parsed as part of the *abstract-declarator* if the type
 of the parameter either names a template parameter pack that has not
 been expanded or contains `auto`; otherwise, it is parsed as part of the
+*parameter-declaration-clause*.[^9]
 ### Default arguments <a id="dcl.fct.default">[[dcl.fct.default]]</a>
 If an *initializer-clause* is specified in a *parameter-declaration*
 this *initializer-clause* is used as a default argument. Default
 arguments will be used in calls where trailing arguments are missing.
+[*Example 1*:
+The declaration
 ``` cpp
 void point(int = 3, int = 4);
 ```
 ```
 The last two calls are equivalent to `point(1,4)` and `point(3,4)`,
 respectively.
+— *end example*]
 A default argument shall be specified only in the
+*parameter-declaration-clause* of a function declaration or
+*lambda-declarator* or in a *template-parameter* ([[temp.param]]); in
+the latter case, the *initializer-clause* shall be an
+*assignment-expression*. A default argument shall not be specified for a
+parameter pack. If it is specified in a *parameter-declaration-clause*,
+it shall not occur within a *declarator* or *abstract-declarator* of a
+*parameter-declaration*.[^10]
 For non-template functions, default arguments can be added in later
 declarations of a function in the same scope. Declarations in different
 scopes have completely distinct sets of default arguments. That is,
 declarations in inner scopes do not acquire default arguments from
 argument shall have a default argument supplied in this or a previous
 declaration or shall be a function parameter pack. A default argument
 shall not be redefined by a later declaration (not even to the same
 value).
+[*Example 2*:
 ``` cpp
 void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
                                 // a parameter with a default argument
 void f(int, int);
 void f(int, int = 7);
 void h() {
   f(3);                         // OK, calls f(3, 7)
+  void f(int = 1, int);         // error: does not use default from surrounding scope
 }
 void m() {
   void f(int, int);             // has no defaults
   f(4);                         // error: wrong number of arguments
   void f(int, int = 5);         // OK
   f(4);                         // OK, calls f(4, 5);
+  void f(int, int = 5);         // error: cannot redefine, even to same value
 }
 void n() {
   f(6);                         // OK, calls f(6, 7)
 }
 ```
+— *end example*]
 For a given inline function defined in different translation units, the
 accumulated sets of default arguments at the end of the translation
 units shall be the same; see  [[basic.def.odr]]. If a friend declaration
 specifies a default argument expression, that declaration shall be a
 definition and shall be the only declaration of the function or function
 the copy-initialization semantics ([[dcl.init]]). The names in the
 default argument are bound, and the semantic constraints are checked, at
 the point where the default argument appears. Name lookup and checking
 of semantic constraints for default arguments in function templates and
 in member functions of class templates are performed as described in
+[[temp.inst]].
+[*Example 3*:
+In the following code, `g` will be called with the value `f(2)`:
 ``` cpp
 int a = 1;
 int f(int);
 int g(int x = f(a));            // default argument: f(::a)
   g();                          // g(f(::a))
   }
 }
 ```
+— *end example*]
+[*Note 1*: In member function declarations, names in default arguments
+are looked up as described in  [[basic.lookup.unqual]]. Access checking
+applies to names in default arguments as described in Clause
+[[class.access]]. — *end note*]
 Except for member functions of class templates, the default arguments in
 a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
 constructor, or copy or move assignment operator ([[class.copy]]) is so
 declared. Default arguments for a member function of a class template
 shall be specified on the initial declaration of the member function
 within the class template.
+[*Example 4*:
 ``` cpp
 class C {
   void f(int i = 3);
   void g(int i, int j = 99);
 };
+void C::f(int i = 3) {}         // error: default argument already specified in class scope
+void C::g(int i = 88, int j) {} // in this translation unit, C::g can be called with no argument
 ```
+— *end example*]
+A local variable shall not appear as a potentially-evaluated expression
+in a default argument.
+[*Example 5*:
 ``` cpp
 void f() {
   int i;
   extern void g(int x = i);         // error
+  extern void h(int x = sizeof(i)); // OK
   // ...
 }
 ```
+— *end example*]
+[*Note 2*:
+The keyword `this` may not appear in a default argument of a member
+function; see  [[expr.prim.this]].
+[*Example 6*:
 ``` cpp
 class A {
   void f(A* p = this) { }           // error
 };
 ```
+— *end example*]
+— *end note*]
 A default argument is evaluated each time the function is called with no
+argument for the corresponding parameter. A parameter shall not appear
+as a potentially-evaluated expression in a default argument. Parameters
+of a function declared before a default argument are in scope and can
+hide namespace and class member names.
+[*Example 7*:
 ``` cpp
 int a;
+int f(int a, int b = a);            // error: parameter a used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter I found
+int h(int a, int b = sizeof(a));    // OK, unevaluated operand
 ```
+— *end example*]
+A non-static member shall not appear in a default argument unless it
+appears as the *id-expression* of a class member access expression (
+[[expr.ref]]) or unless it is used to form a pointer to member (
+[[expr.unary.op]]).
+[*Example 8*:
+The declaration of `X::mem1()` in the following example is ill-formed
+because no object is supplied for the non-static member `X::a` used as
+an initializer.
 ``` cpp
 int b;
 class X {
   int a;
+  int mem1(int i = a); // error: non-static member a used as default argument
   int mem2(int i = b);              // OK;  use X::b
   static int b;
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
 is needed to access the static member `X::b`. Classes, objects, and
+members are described in Clause  [[class]].
+— *end example*]
+A default argument is not part of the type of a function.
+[*Example 9*:
 ``` cpp
 int f(int = 0);
 void h() {
 int (*p1)(int) = &f;
 int (*p2)() = &f;                   // error: type mismatch
 ```
+— *end example*]
 When a declaration of a function is introduced by way of a
 *using-declaration* ([[namespace.udecl]]), any default argument
 information associated with the declaration is made known as well. If
 the function is redeclared thereafter in the namespace with additional
 default arguments, the additional arguments are also known at any point
 in the declaration of the virtual function determined by the static type
 of the pointer or reference denoting the object. An overriding function
 in a derived class does not acquire default arguments from the function
 it overrides.
+[*Example 10*:
 ``` cpp
 struct A {
   virtual void f(int a = 7);
 };
 struct B : public A {
   pa->f();          // OK, calls pa->B::f(7)
   pb->f();          // error: wrong number of arguments for B::f()
 }
 ```
+— *end example*]

Diff to HTML by rtfpessoa