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

Files changed (1) hide show

tmp/tmpsv4lou79/{from.md → to.md} +155 -66

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

@@ -1,46 +1,55 @@
-### Functions <a id="dcl.fct">[[dcl.fct]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
-'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
   ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, the type of the
-*declarator-id* in `D` is “*derived-declarator-type-list* `noexcept`
-function of (*parameter-declaration-clause*) *cv-qualifier-seq*ₒₚₜ
-*ref-qualifier*ₒₚₜ  returning `T`”, where the optional `noexcept` is
-present if and only if the exception specification ([[except.spec]]) is
-non-throwing. The optional *attribute-specifier-seq* appertains to the
-function type.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
-'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
   ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-type
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, `T` shall be the single
 *type-specifier* `auto`. The type of the *declarator-id* in `D` is
-“*derived-declarator-type-list* `noexcept` function of
-(*parameter-declaration-clause*) *cv-qualifier-seq**ref-qualifier*
-returning `U`”, where `U` is the type specified by the
-*trailing-return-type*, and where the optional `noexcept` is present if
-and only if the exception specification is non-throwing. The optional
-*attribute-specifier-seq* appertains to the function type.
-A type of either form is a *function type*.[^8]
 ``` bnf
 parameter-declaration-clause:
     parameter-declaration-listₒₚₜ '...'ₒₚₜ
-    parameter-declaration-list ', ...'
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
@@ -66,17 +75,18 @@ arguments specified on the function call; see
 [[expr.call]]. — *end note*]
 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 “`...`”.
 [*Example 1*:
 The declaration
@@ -91,31 +101,28 @@ arguments.
 printf("hello world");
 printf("a=%d b=%d", a, b);
 ```
 However, the first argument must be of a type that can be converted to a
-`const` `char*`
 — *end example*]
 [*Note 2*: The standard header `<cstdarg>` contains a mechanism for
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
 [[support.runtime]]). — *end note*]
-A single name can be used for several different functions in a single
-scope; this is function overloading (Clause  [[over]]). All declarations
-for a function shall agree exactly in both the return type and the
-parameter-type-list. 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 *parameter-type-list*.
 [*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*]
@@ -125,20 +132,20 @@ A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 - 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;              // ill-formed: does not declare a member function
 struct S {
   FIC f;            // OK
 };
 FIC S::*pm = &S::f; // OK
 ```
@@ -164,11 +171,12 @@ struct S {
 — *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]]), 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*]
@@ -179,48 +187,52 @@ 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*]
 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 (possibly cv-qualified) class type in the context of the
-function definition unless the function is deleted (
-[[dcl.fct.def.delete]]).
 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 { }           // ill-formed
 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.proto]]). — *end note*]
 [*Example 6*:
 The declaration
@@ -285,24 +297,101 @@ 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.
 [*Note 8*: A function template is not a function. — *end note*]
-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]]).
-[*Note 9*: Otherwise, the *parameter-declaration* is part of a
-*template-parameter-list* and the parameter pack is a template parameter
-pack; see  [[temp.param]]. — *end note*]
-A function parameter pack is a pack expansion ([[temp.variadic]]).
 [*Example 7*:
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
 float subtract(int, int);
@@ -317,7 +406,7 @@ 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 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*.[^9]

+#### Functions <a id="dcl.fct">[[dcl.fct]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
+'D1' '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
   ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, the type of the
+*declarator-id* in `D` is “*derived-declarator-type-list* `noexcept`ₒₚₜ
+function of parameter-type-list *cv-qualifier-seq*ₒₚₜ
+*ref-qualifier*ₒₚₜ  returning `T`”, where
+- the parameter-type-list is derived from the
+  *parameter-declaration-clause* as described below and
+- the optional `noexcept` is present if and only if the exception
+  specification [[except.spec]] is non-throwing.
+The optional *attribute-specifier-seq* appertains to the function type.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
+'D1' '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
   ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-type
 ```
 and the type of the contained *declarator-id* in the declaration `T`
 `D1` is “*derived-declarator-type-list* `T`”, `T` shall be the single
 *type-specifier* `auto`. The type of the *declarator-id* in `D` is
+“*derived-declarator-type-list* `noexcept`ₒₚₜ  function of
+parameter-type-list *cv-qualifier-seq*ₒₚₜ  *ref-qualifier*ₒₚₜ  returning
+`U`”, where
+- the parameter-type-list is derived from the
+  *parameter-declaration-clause* as described below,
+- `U` is the type specified by the *trailing-return-type*, and
+- the optional `noexcept` is present if and only if the exception
+  specification is non-throwing.
+The optional *attribute-specifier-seq* appertains to the function type.
+A type of either form is a *function type*.[^2]
 ``` bnf
 parameter-declaration-clause:
     parameter-declaration-listₒₚₜ '...'ₒₚₜ
+    parameter-declaration-list ',' '...'
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
 [[expr.call]]. — *end note*]
 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`.
+A parameter with volatile-qualified type is deprecated; see
+[[depr.volatile.type]]. 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 “`...`”.
 [*Example 1*:
 The declaration
 printf("hello world");
 printf("a=%d b=%d", a, b);
 ```
 However, the first argument must be of a type that can be converted to a
+`const` `char*`.
 — *end example*]
 [*Note 2*: The standard header `<cstdarg>` contains a mechanism for
 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
+*parameter-type-list*.
 [*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*]
 - 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 {
   FIC f;            // OK
 };
 FIC S::*pm = &S::f; // OK
 ```
 — *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*]
 ``` cpp
 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
 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
+*template-parameter* for each generic parameter type placeholder of the
+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 = /* ... */;
+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...);
+template<C3 T>       void g4(T);
+```
+Abbreviated function templates can be specialized like all function
+templates.
+``` cpp
+template<> void g1<int>(const int*, const double&); // OK, specialization of g1<int, const double>
+```
+— *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>
+  void g(T x, U y, C auto z);
+```
+This is functionally equivalent to each of the following two
+declarations.
+``` cpp
+template<typename T, C U, C W>
+  void g(T x, U y, W z);
+template<typename T, typename U, typename W>
+  requires C<U> && C<W>
+  void g(T x, U y, W z);
+```
+— *end example*]
+A function declaration at block scope shall not declare an abbreviated
+function template.
+A *declarator-id* or *abstract-declarator* containing an ellipsis shall
+only be used in a *parameter-declaration*. When it is part of a
+*parameter-declaration-clause*, the *parameter-declaration* declares 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);
 float subtract(int, int);
 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*.[^3]

Diff to HTML by rtfpessoa