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

Files changed (1) hide show

tmp/tmpwerxdl2x/{from.md → to.md} +49 -40

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

@@ -1,10 +1,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
-arguments will be used in calls where trailing arguments are missing.
 [*Example 1*:
 The declaration
@@ -24,27 +26,30 @@ respectively.
 — *end example*]
 A default argument shall be specified only in the
 *parameter-declaration-clause* of a function declaration or
-*lambda-declarator* or in a *template-parameter* ([[temp.param]]); in
-the latter case, the *initializer-clause* shall be an
 *assignment-expression*. A default argument shall not be specified for a
-parameter pack. If it is specified in a *parameter-declaration-clause*,
-it shall not occur within a *declarator* or *abstract-declarator* of a
-*parameter-declaration*.[^10]
 For non-template functions, default arguments can be added in later
 declarations of a function in the same scope. Declarations in different
 scopes have completely distinct sets of default arguments. That is,
 declarations in inner scopes do not acquire default arguments from
 declarations in outer scopes, and vice versa. In a given function
 declaration, each parameter subsequent to a parameter with a default
 argument shall have a default argument supplied in this or a previous
-declaration or shall be a function parameter pack. A default argument
-shall not be redefined by a later declaration (not even to the same
-value).
 [*Example 2*:
 ``` cpp
 void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
@@ -63,28 +68,32 @@ void m() {
   void f(int, int = 5);         // error: cannot redefine, even to same value
 }
 void n() {
   f(6);                         // OK, calls f(6, 7)
 }
 ```
 — *end example*]
 For a given inline function defined in different translation units, the
 accumulated sets of default arguments at the end of the translation
-units shall be the same; see  [[basic.def.odr]]. If a friend declaration
-specifies a default argument expression, that declaration shall be a
-definition and shall be the only declaration of the function or function
-template in the translation unit.
 The default argument has the same semantic constraints as the
 initializer in a declaration of a variable of the parameter type, using
-the copy-initialization semantics ([[dcl.init]]). The names in the
-default argument are bound, and the semantic constraints are checked, at
-the point where the default argument appears. Name lookup and checking
-of semantic constraints for default arguments in function templates and
-in member functions of class templates are performed as described in
 [[temp.inst]].
 [*Example 3*:
 In the following code, `g` will be called with the value `f(2)`:
@@ -103,24 +112,24 @@ void h() {
 }
 ```
 — *end example*]
-[*Note 1*: In member function declarations, names in default arguments
 are looked up as described in  [[basic.lookup.unqual]]. Access checking
-applies to names in default arguments as described in Clause
 [[class.access]]. — *end note*]
 Except for member functions of class templates, the default arguments in
 a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
-ill-formed if a default constructor ([[class.ctor]]), copy or move
-constructor, or copy or move assignment operator ([[class.copy]]) is so
-declared. Default arguments for a member function of a class template
-shall be specified on the initial declaration of the member function
-within the class template.
 [*Example 4*:
 ``` cpp
 class C {
@@ -132,12 +141,12 @@ void C::f(int i = 3) {}         // error: default argument already specified in
 void C::g(int i = 88, int j) {} // in this translation unit, C::g can be called with no argument
 ```
 — *end example*]
-A local variable shall not appear as a potentially-evaluated expression
-in a default argument.
 [*Example 5*:
 ``` cpp
 void f() {
@@ -148,11 +157,11 @@ void f() {
 }
 ```
 — *end example*]
-[*Note 2*:
 The keyword `this` may not appear in a default argument of a member
 function; see  [[expr.prim.this]].
 [*Example 6*:
@@ -184,13 +193,13 @@ int h(int a, int b = sizeof(a));    // OK, unevaluated operand
 ```
 — *end example*]
 A non-static member shall not appear in a default argument unless it
-appears as the *id-expression* of a class member access expression (
-[[expr.ref]]) or unless it is used to form a pointer to member (
-[[expr.unary.op]]).
 [*Example 8*:
 The declaration of `X::mem1()` in the following example is ill-formed
 because no object is supplied for the non-static member `X::a` used as
@@ -206,11 +215,11 @@ class X {
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
 is needed to access the static member `X::b`. Classes, objects, and
-members are described in Clause  [[class]].
 — *end example*]
 A default argument is not part of the type of a function.
@@ -229,21 +238,21 @@ int (*p2)() = &f;                   // error: type mismatch
 ```
 — *end example*]
 When a declaration of a function is introduced by way of a
-*using-declaration* ([[namespace.udecl]]), any default argument
 information associated with the declaration is made known as well. If
 the function is redeclared thereafter in the namespace with additional
 default arguments, the additional arguments are also known at any point
 following the redeclaration where the *using-declaration* is in scope.
-A virtual function call ([[class.virtual]]) uses the default arguments
-in the declaration of the virtual function determined by the static type
-of the pointer or reference denoting the object. An overriding function
-in a derived class does not acquire default arguments from the function
-it overrides.
 [*Example 10*:
 ``` cpp
 struct A {

+#### Default arguments <a id="dcl.fct.default">[[dcl.fct.default]]</a>
 If an *initializer-clause* is specified in a *parameter-declaration*
+this *initializer-clause* is used as a default argument.
+[*Note 1*: Default arguments will be used in calls where trailing
+arguments are missing [[expr.call]]. — *end note*]
 [*Example 1*:
 The declaration
 — *end example*]
 A default argument shall be specified only in the
 *parameter-declaration-clause* of a function declaration or
+*lambda-declarator* or in a *template-parameter* [[temp.param]]; in the
+latter case, the *initializer-clause* shall be an
 *assignment-expression*. A default argument shall not be specified for a
+template parameter pack or a function parameter pack. If it is specified
+in a *parameter-declaration-clause*, it shall not occur within a
+*declarator* or *abstract-declarator* of a *parameter-declaration*.[^4]
 For non-template functions, default arguments can be added in later
 declarations of a function in the same scope. Declarations in different
 scopes have completely distinct sets of default arguments. That is,
 declarations in inner scopes do not acquire default arguments from
 declarations in outer scopes, and vice versa. In a given function
 declaration, each parameter subsequent to a parameter with a default
 argument shall have a default argument supplied in this or a previous
+declaration, unless the parameter was expanded from a parameter pack, or
+shall be a function parameter pack.
+[*Note 2*: A default argument cannot be redefined by a later
+declaration (not even to the same value)
+[[basic.def.odr]]. — *end note*]
 [*Example 2*:
 ``` cpp
 void g(int = 0, ...);           // OK, ellipsis is not a parameter so it can follow
   void f(int, int = 5);         // error: cannot redefine, even to same value
 }
 void n() {
   f(6);                         // OK, calls f(6, 7)
 }
+template<class ... T> struct C {
+  void f(int n = 0, T...);
+};
+C<int> c;                       // OK, instantiates declaration void C::f(int n = 0, int)
 ```
 — *end example*]
 For a given inline function defined in different translation units, the
 accumulated sets of default arguments at the end of the translation
+units shall be the same; no diagnostic is required. If a friend
+declaration specifies a default argument expression, that declaration
+shall be a definition and shall be the only declaration of the function
+or function template in the translation unit.
 The default argument has the same semantic constraints as the
 initializer in a declaration of a variable of the parameter type, using
+the copy-initialization semantics [[dcl.init]]. The names in the default
+argument are bound, and the semantic constraints are checked, at the
+point where the default argument appears. Name lookup and checking of
+semantic constraints for default arguments in function templates and in
+member functions of class templates are performed as described in
 [[temp.inst]].
 [*Example 3*:
 In the following code, `g` will be called with the value `f(2)`:
 }
 ```
 — *end example*]
+[*Note 3*: In member function declarations, names in default arguments
 are looked up as described in  [[basic.lookup.unqual]]. Access checking
+applies to names in default arguments as described in
 [[class.access]]. — *end note*]
 Except for member functions of class templates, the default arguments in
 a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
+ill-formed if a default constructor [[class.default.ctor]], copy or move
+constructor [[class.copy.ctor]], or copy or move assignment operator
+[[class.copy.assign]] is so declared. Default arguments for a member
+function of a class template shall be specified on the initial
+declaration of the member function within the class template.
 [*Example 4*:
 ``` cpp
 class C {
 void C::g(int i = 88, int j) {} // in this translation unit, C::g can be called with no argument
 ```
 — *end example*]
+[*Note 4*: A local variable cannot be odr-used [[basic.def.odr]] in a
+default argument. — *end note*]
 [*Example 5*:
 ``` cpp
 void f() {
 }
 ```
 — *end example*]
+[*Note 5*:
 The keyword `this` may not appear in a default argument of a member
 function; see  [[expr.prim.this]].
 [*Example 6*:
 ```
 — *end example*]
 A non-static member shall not appear in a default argument unless it
+appears as the *id-expression* of a class member access expression
+[[expr.ref]] or unless it is used to form a pointer to member
+[[expr.unary.op]].
 [*Example 8*:
 The declaration of `X::mem1()` in the following example is ill-formed
 because no object is supplied for the non-static member `X::a` used as
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
 is needed to access the static member `X::b`. Classes, objects, and
+members are described in [[class]].
 — *end example*]
 A default argument is not part of the type of a function.
 ```
 — *end example*]
 When a declaration of a function is introduced by way of a
+*using-declaration* [[namespace.udecl]], any default argument
 information associated with the declaration is made known as well. If
 the function is redeclared thereafter in the namespace with additional
 default arguments, the additional arguments are also known at any point
 following the redeclaration where the *using-declaration* is in scope.
+A virtual function call [[class.virtual]] uses the default arguments in
+the declaration of the virtual function determined by the static type of
+the pointer or reference denoting the object. An overriding function in
+a derived class does not acquire default arguments from the function it
+overrides.
 [*Example 10*:
 ``` cpp
 struct A {

Diff to HTML by rtfpessoa