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

Files changed (1) hide show

tmp/tmpb0zwb4qb/{from.md → to.md} +108 -42

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

@@ -56,13 +56,13 @@ parameter-declaration-list:
     parameter-declaration-list ',' parameter-declaration
 ```
 ``` bnf
 parameter-declaration:
-    attribute-specifier-seqₒₚₜ decl-specifier-seq declarator
     attribute-specifier-seqₒₚₜ decl-specifier-seq declarator '=' initializer-clause
-    attribute-specifier-seqₒₚₜ decl-specifier-seq abstract-declaratorₒₚₜ
     attribute-specifier-seqₒₚₜ decl-specifier-seq abstract-declaratorₒₚₜ '=' initializer-clause
 ```
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
@@ -111,12 +111,12 @@ However, the first argument must be of a type that can be converted to a
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
 [[support.runtime]]). — *end note*]
 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
@@ -124,24 +124,94 @@ ellipsis or a function parameter pack is the function’s
 [*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 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]].
-[*Example 2*:
 ``` cpp
 typedef int FIC(int) const;
 FIC f;              // error: does not declare a member function
 struct S {
@@ -154,35 +224,35 @@ 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.
-[*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]] or the trailing *requires-clause*
 [[dcl.decl]], 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);
@@ -191,50 +261,46 @@ int fseek(FILE*, long, int);
 declares a function taking three arguments of the specified types, and
 returning `int` [[dcl.type]].
 — *end example*]
-A single name can be used for several different functions in a single
-scope; this is function overloading [[over]]. All declarations for a
-function shall have equivalent return types, parameter-type-lists, and
-*requires-clause*s [[temp.over.link]].
-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.
 A volatile-qualified return type is deprecated; see
 [[depr.volatile.type]].
 Types shall not be defined in return or parameter types.
 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 { }           // error
-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.param]]. — *end note*]
-[*Example 6*:
 The declaration
 ``` cpp
 int i,
@@ -260,15 +326,15 @@ calling of a function `fpi`, and then using indirection through the
 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);
 ```
@@ -295,11 +361,11 @@ 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*]
 An *abbreviated function template* is a function declaration that has
 one or more generic parameter type placeholders [[dcl.spec.auto]]. An
 abbreviated function template is equivalent to a function template
 [[temp.fct]] whose *template-parameter-list* includes one invented type
@@ -308,18 +374,18 @@ function declaration, in order of appearance. For a
 *placeholder-type-specifier* of the form `auto`, the invented parameter
 is an unconstrained *type-parameter*. For a *placeholder-type-specifier*
 of the form *type-constraint* `auto`, the invented parameter is a
 *type-parameter* with that *type-constraint*. The invented type
 *template-parameter* is a template parameter pack if the corresponding
-*parameter-declaration* declares a function parameter pack [[dcl.fct]].
-If the placeholder contains `decltype(auto)`, the program is ill-formed.
-The adjusted function parameters of an abbreviated function template are
 derived from the *parameter-declaration-clause* by replacing each
 occurrence of a placeholder with the name of the corresponding invented
 *template-parameter*.
-[*Example 7*:
 ``` cpp
 template<typename T>     concept C1 = /* ... */;
 template<typename T>     concept C2 = /* ... */;
 template<typename... Ts> concept C3 = /* ... */;
@@ -328,12 +394,12 @@ void g1(const C1 auto*, C2 auto&);
 void g2(C1 auto&...);
 void g3(C3 auto...);
 void g4(C3 auto);
 ```
-These declarations are functionally equivalent (but not equivalent) to
-the following declarations.
 ``` cpp
 template<C1 T, C2 U> void g1(const T*, U&);
 template<C1... Ts>   void g2(Ts&...);
 template<C3... Ts>   void g3(Ts...);
@@ -348,15 +414,15 @@ template<> void g1<int>(const int*, const double&); // OK, specialization of g1<
 ```
 — *end example*]
 An abbreviated function template can have a *template-head*. The
-invented *template-parameters* are appended to the
 *template-parameter-list* after the explicitly declared
-*template-parameters*.
-[*Example 8*:
 ``` cpp
 template<typename> concept C = /* ... */;
 template <typename T, C U>
@@ -386,11 +452,11 @@ only be used in a *parameter-declaration*. When it is part of a
 function parameter pack [[temp.variadic]]. Otherwise, the
 *parameter-declaration* is part of a *template-parameter-list* and
 declares a template parameter pack; see  [[temp.param]]. A function
 parameter pack is a pack expansion [[temp.variadic]].
-[*Example 9*:
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);

     parameter-declaration-list ',' parameter-declaration
 ```
 ``` bnf
 parameter-declaration:
+    attribute-specifier-seqₒₚₜ thisₒₚₜ decl-specifier-seq declarator
     attribute-specifier-seqₒₚₜ decl-specifier-seq declarator '=' initializer-clause
+    attribute-specifier-seqₒₚₜ thisₒₚₜ decl-specifier-seq abstract-declaratorₒₚₜ
     attribute-specifier-seqₒₚₜ decl-specifier-seq abstract-declaratorₒₚₜ '=' initializer-clause
 ```
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
 [[support.runtime]]). — *end note*]
 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 *parameter-declaration* [[dcl.decl]]. 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
 [*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*]
+[*Example 2*:
+``` cpp
+void f(char*);                  // #1
+void f(char[]) {}               // defines #1
+void f(const char*) {}          // OK, another overload
+void f(char *const) {}          // error: redefines #1
+void g(char(*)[2]);             // #2
+void g(char[3][2]) {}           // defines #2
+void g(char[3][3]) {}           // OK, another overload
+void h(int x(const int));       // #3
+void h(int (*)(int)) {}         // defines #3
+```
+— *end example*]
+An *explicit-object-parameter-declaration* is a *parameter-declaration*
+with a `this` specifier. An explicit-object-parameter-declaration shall
+appear only as the first *parameter-declaration* of a
+*parameter-declaration-list* of either:
+- a *member-declarator* that declares a member function [[class.mem]],
+  or
+- a *lambda-declarator* [[expr.prim.lambda]].
+A *member-declarator* with an explicit-object-parameter-declaration
+shall not include a *ref-qualifier* or a *cv-qualifier-seq* and shall
+not be declared `static` or `virtual`.
+[*Example 3*:
+``` cpp
+struct C {
+  void f(this C& self);
+  template <typename Self> void g(this Self&& self, int);
+  void h(this C) const;         // error: const not allowed here
+};
+void test(C c) {
+  c.f();                        // OK, calls C::f
+  c.g(42);                      // OK, calls C::g<C&>
+  std::move(c).g(42);           // OK, calls C::g<C>
+}
+```
+— *end example*]
+A function parameter declared with an
+explicit-object-parameter-declaration is an *explicit object parameter*.
+An explicit object parameter shall not be a function parameter pack
+[[temp.variadic]]. An *explicit object member function* is a non-static
+member function with an explicit object parameter. An
+*implicit object member function* is a non-static member function
+without an explicit object parameter.
+The *object parameter* of a non-static member function is either the
+explicit object parameter or the implicit object parameter
+[[over.match.funcs]].
+A *non-object parameter* is a function parameter that is not the
+explicit object parameter. The *non-object-parameter-type-list* of a
+member function is the parameter-type-list of that function with the
+explicit object parameter, if any, omitted.
+[*Note 4*: The non-object-parameter-type-list consists of the adjusted
+types of all the non-object parameters. — *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 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]].
+[*Example 4*:
 ``` cpp
 typedef int FIC(int) const;
 FIC f;              // error: does not declare a member function
 struct S {
 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 5*: 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 5*:
 ``` 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]] or the trailing *requires-clause*
 [[dcl.decl]], are part of the function type.
+[*Note 6*: Function types are checked during the assignments and
 initializations of pointers to functions, references to functions, and
 pointers to member functions. — *end note*]
+[*Example 6*:
 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*]
+[*Note 7*: A single name can be used for several different functions in
+a single scope; this is function overloading [[over]]. — *end note*]
+The return type shall be a non-array object type, a reference type, or
+cv `void`.
+[*Note 8*: An array of placeholder type is considered an array
+type. — *end note*]
 A volatile-qualified return type is deprecated; see
 [[depr.volatile.type]].
 Types shall not be defined in return or parameter types.
 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 7*:
 ``` cpp
 typedef void F();
+F  fv;              // OK, equivalent to void fv();
 F  fv { }           // error
+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 9*: 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. — *end note*]
+[*Example 8*:
 The declaration
 ``` cpp
 int i,
 to indicate that indirection through a pointer to a function yields a
 function, which is then called.
 — *end example*]
+[*Note 10*:
 Typedefs and *trailing-return-type*s are sometimes convenient when the
 return type of a function is complex. For example, the function `fpif`
+above can be declared
 ``` cpp
 typedef int  IFUNC(int);
 IFUNC*  fpif(int);
 ```
 — *end note*]
 A *non-template function* is a function that is not a function template
 specialization.
+[*Note 11*: A function template is not a function. — *end note*]
 An *abbreviated function template* is a function declaration that has
 one or more generic parameter type placeholders [[dcl.spec.auto]]. An
 abbreviated function template is equivalent to a function template
 [[temp.fct]] whose *template-parameter-list* includes one invented type
 *placeholder-type-specifier* of the form `auto`, the invented parameter
 is an unconstrained *type-parameter*. For a *placeholder-type-specifier*
 of the form *type-constraint* `auto`, the invented parameter is a
 *type-parameter* with that *type-constraint*. The invented type
 *template-parameter* is a template parameter pack if the corresponding
+*parameter-declaration* declares a function parameter pack. If the
+placeholder contains `decltype(auto)`, the program is ill-formed. The
+adjusted function parameters of an abbreviated function template are
 derived from the *parameter-declaration-clause* by replacing each
 occurrence of a placeholder with the name of the corresponding invented
 *template-parameter*.
+[*Example 9*:
 ``` cpp
 template<typename T>     concept C1 = /* ... */;
 template<typename T>     concept C2 = /* ... */;
 template<typename... Ts> concept C3 = /* ... */;
 void g2(C1 auto&...);
 void g3(C3 auto...);
 void g4(C3 auto);
 ```
+The declarations above are functionally equivalent (but not equivalent)
+to their respective declarations below:
 ``` cpp
 template<C1 T, C2 U> void g1(const T*, U&);
 template<C1... Ts>   void g2(Ts&...);
 template<C3... Ts>   void g3(Ts...);
 ```
 — *end example*]
 An abbreviated function template can have a *template-head*. The
+invented *template-parameter*s are appended to the
 *template-parameter-list* after the explicitly declared
+*template-parameter*s.
+[*Example 10*:
 ``` cpp
 template<typename> concept C = /* ... */;
 template <typename T, C U>
 function parameter pack [[temp.variadic]]. Otherwise, the
 *parameter-declaration* is part of a *template-parameter-list* and
 declares a template parameter pack; see  [[temp.param]]. A function
 parameter pack is a pack expansion [[temp.variadic]].
+[*Example 11*:
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);

Diff to HTML by rtfpessoa