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

Files changed (1) hide show

tmp/tmpxl00m0tu/{from.md → to.md} +113 -112

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

@@ -2,32 +2,26 @@
 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.conv]], [[class.dtor]], [[over.oper]]) and for the declaration
-of template specializations or partial specializations ([[temp.spec]]).
-A *declarator-id* shall not be qualified except for the definition of a
-member function ([[class.mfct]]) or static data member (
-[[class.static]]) outside of its class, the definition or explicit
-instantiation of a function or variable member of a namespace outside of
-its namespace, or the definition of an explicit specialization outside
-of its namespace, or the declaration of a friend function that is a
-member of another class or namespace ([[class.friend]]). 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
@@ -139,13 +133,15 @@ cv-unqualified pointer later, for example:
 *p = 5;             // clobber ci
 ```
 See also  [[expr.ass]] and  [[dcl.init]].
-There are no pointers to references; see  [[dcl.ref]]. 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
@@ -156,13 +152,13 @@ In a declaration `T` `D` where `D` has either of the forms
 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 ([[dcl.typedef]]) or of a
-template type argument ([[temp.arg]]), 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
 ```
@@ -232,20 +228,20 @@ 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 dereferencing 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 ([[dcl.typedef]]), a type *template-parameter* (
-[[temp.arg.type]]), 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;
@@ -259,10 +255,13 @@ 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&
 ```
 ### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
@@ -326,24 +325,25 @@ 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 an
-integral constant expression 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''
@@ -472,11 +472,11 @@ and the type of the contained *declarator-id* in the declaration `T`
 “*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*.[^10]
 ``` bnf
 parameter-declaration-clause:
     parameter-declaration-listₒₚₜ ...ₒₚₜ
     parameter-declaration-list ',' ...
@@ -502,18 +502,18 @@ 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. The parameter list `(void)` is equivalent to the empty
-parameter list. Except for this special case, `void` shall not be a
-parameter type (though types derived from `void`, such as `void*`, can).
-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*, ...);
 ```
@@ -547,20 +547,31 @@ 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 *cv-qualifier-seq* or a *ref-qualifier* shall only be part of:
 - 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.names]]).
 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
@@ -589,20 +600,21 @@ 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.[^11] 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
-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
@@ -610,34 +622,18 @@ typedef void F();
 F  fv;              // OK: equivalent to void fv();
 F  fv { }           // ill-formed
 void fv() { }       // OK: definition of fv
 ```
-A typedef of a function type whose declarator includes a
-*cv-qualifier-seq* shall be used only to declare the function type for a
-non-static member function, to declare the function type to which a
-pointer to member refers, or to declare the top-level function type of
-another function typedef declaration.
-``` 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
-```
 An identifier can optionally be provided as a parameter name; if present
-in a function definition ([[dcl.fct.def]]), it names a parameter
-(sometimes called “formal argument”). 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,
@@ -671,11 +667,11 @@ IFUNC*  fpif(int);
 ```
 or
 ``` cpp
-auto fpif(int)->int(*)(int)
 ```
 A *trailing-return-type* is most useful for a type that would be more
 complicated to specify before the *declarator-id*:
@@ -687,10 +683,13 @@ rather than
 ``` cpp
 template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);
 ```
 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
@@ -710,13 +709,13 @@ 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 names a template parameter pack that has not been
-expanded; otherwise, it is parsed as part of the
-*parameter-declaration-clause*.[^12]
 ### 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
@@ -742,11 +741,11 @@ 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*.[^13]
 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
@@ -785,20 +784,19 @@ 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.
-A default argument is implicitly converted (Clause  [[conv]]) to the
-parameter type. 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]]. 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)
@@ -817,13 +815,16 @@ 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. 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);
@@ -852,16 +853,16 @@ function.
 class A {
   void f(A* p = this) { }       // error
 };
 ```
-Default arguments are evaluated each time the function is called. 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

 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
 *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
 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
 ```
 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;
 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
 “*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''
 “*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 ',' ...
 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*, ...);
 ```
 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:
 - 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]]).
+``` 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
 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
 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,
 ```
 or
 ``` cpp
+auto fpif(int)->int(*)(int);
 ```
 A *trailing-return-type* is most useful for a type that would be more
 complicated to specify before the *declarator-id*:
 ``` 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
 ```
 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
 *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
 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]]. 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)
 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
+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);
 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

Diff to HTML by rtfpessoa