[dcl.fct.default] - C++20 → C++23

Files changed (1) hide show

tmp/tmpabsxgs0l/{from.md → to.md} +39 -33

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

@@ -34,18 +34,18 @@ latter case, the *initializer-clause* shall be an
 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*]
@@ -79,22 +79,26 @@ C<int> c;                       // OK, instantiates declaration void C::f(int n
 — *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)`:
@@ -112,14 +116,13 @@ void h() {
 }
 ```
 — *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
@@ -136,16 +139,16 @@ 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*]
-[*Note 4*: A local variable cannot be odr-used [[basic.def.odr]] in a
 default argument. — *end note*]
 [*Example 5*:
 ``` cpp
@@ -159,11 +162,11 @@ 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*:
 ``` cpp
@@ -176,22 +179,24 @@ class A {
 — *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
@@ -237,16 +242,17 @@ 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
-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

 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 that inhabit the same scope. Declarations
+that inhabit 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*]
 — *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 D specifies a default argument expression, that declaration
+shall be a definition and there shall be no other declaration of the
+function or function template which is reachable from D or from which D
+is reachable.
 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 looked up, and the semantic constraints are checked, at the
+point where the default argument appears, except that an immediate
+invocation [[expr.const]] that is a potentially-evaluated subexpression
+[[intro.execution]] of the *initializer-clause* in a
+*parameter-declaration* is neither evaluated nor checked for whether it
+is a constant expression at that point. Name lookup and checking of
+semantic constraints for default arguments of templated functions 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*: A default argument is a complete-class context
+[[class.mem]]. 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
   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 arguments
 ```
 — *end example*]
+[*Note 4*: A local variable cannot be odr-used [[term.odr.use]] in a
 default argument. — *end note*]
 [*Example 5*:
 ``` cpp
 — *end example*]
 [*Note 5*:
+The keyword `this` cannot appear in a default argument of a member
 function; see  [[expr.prim.this]].
 [*Example 6*:
 ``` cpp
 — *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.
+[*Note 6*: Parameters of a function declared before a default argument
+are in scope and can hide namespace and class member
+names. — *end note*]
 [*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[term.unevaluated.operand]
 ```
 — *end example*]
 A non-static member shall not appear in a default argument unless it
 int (*p2)() = &f;                   // error: type mismatch
 ```
 — *end example*]
+When an overload set contains a declaration of a function that inhabits
+a scope S, any default argument associated with any reachable
+declaration that inhabits S is available to the call.
+[*Note 7*: The candidate might have been found through a
+*using-declarator* from which the declaration that provides the default
+argument is not reachable. — *end note*]
 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

Diff to HTML by rtfpessoa