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

Files changed (1) hide show

tmp/tmpr93t4b0i/{from.md → to.md} +26 -21

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

@@ -26,20 +26,19 @@ 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
-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
@@ -120,19 +119,19 @@ void h() {
 [*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
 ill-formed if a default constructor [[class.default.ctor]], copy or move
 constructor [[class.copy.ctor]], or copy or move assignment operator
 [[class.copy.assign]] is so declared. Default arguments for a member
-function of a class template shall be specified on the initial
-declaration of the member function within the class template.
 [*Example 4*:
 ``` cpp
 class C {
@@ -197,14 +196,17 @@ 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
-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
@@ -213,11 +215,13 @@ 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
@@ -242,15 +246,16 @@ int (*p1)(int) = &f;
 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

 — *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]]. A
+default argument shall not be specified for a template parameter pack or
+a function parameter pack. If it is specified in a
+*parameter-declaration-clause*, it shall not occur within a *declarator*
+or *abstract-declarator* of a *parameter-declaration*.[^4]
 For non-template functions, default arguments can be added in later
+declarations of a function that have the same host scope. Declarations
+that have different host 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
 [*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 templated classes, the default arguments
+in a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
 ill-formed if a default constructor [[class.default.ctor]], copy or move
 constructor [[class.copy.ctor]], or copy or move assignment operator
 [[class.copy.assign]] is so declared. Default arguments for a member
+function of a templated class shall be specified on the initial
+declaration of the member function within the templated class.
 [*Example 4*:
 ``` cpp
 class C {
 int h(int a, int b = sizeof(a));    // OK, unevaluated operand[term.unevaluated.operand]
 ```
 — *end example*]
+A non-static member shall not be designated in a default argument unless
+- it is designated by the *id-expression* or *splice-expression* of a
+  class member access expression [[expr.ref]],
+- it is designated by an expression used to form a pointer to member
+  [[expr.unary.op]], or
+- it appears as the operand of a *reflect-expression* [[expr.reflect]].
 [*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
 ``` 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
+  consteval void mem3(std::meta::info r = ^^a) {}   // OK
+  int mem4(int i = [:^^a:]);                // error: non-static member a designated in default argument
   static int b;
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
 int (*p2)() = &f;                   // error: type mismatch
 ```
 — *end example*]
+[*Note 7*: When an overload set contains a declaration of a function
+whose host scope is S, any default argument associated with any
+reachable declaration whose host scope is S is available to the call
+[[over.match.viable]]. — *end note*]
+[*Note 8*: 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

Diff to HTML by rtfpessoa