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

Files changed (1) hide show

tmp/tmph_v8ldyn/{from.md → to.md} +117 -64

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

@@ -2,39 +2,45 @@
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ exception-specificationₒₚₜ 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 “ function of ( ) returning `T`”. 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ₒₚₜ exception-specificationₒₚₜ 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* function of
-(*parameter-declaration-clause*) *cv-qualifier-seq*
-*ref-qualifier*returning *trailing-return-type*”. The optional
 *attribute-specifier-seq* appertains to the function type.
-A type of either form is a *function type*.[^9]
 ``` bnf
 parameter-declaration-clause:
-    parameter-declaration-listₒₚₜ ...ₒₚₜ
-    parameter-declaration-list ',' ...
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
@@ -51,23 +57,30 @@ parameter-declaration:
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
 The *parameter-declaration-clause* determines the arguments that can be
-specified, and their processing, when the function is called. the
-*parameter-declaration-clause* is used to convert the arguments
-specified on the function call; see  [[expr.call]]. 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 “”. the declaration
 ``` cpp
 int printf(const char*, ...);
 ```
@@ -78,31 +91,35 @@ 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*` The standard header `<cstdarg>` contains a mechanism for
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
-[[support.runtime]]).
 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 “function returning `T`” is adjusted
-to be “pointer to `T`” or “pointer to function returning `T`,”
-respectively. 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*. 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.
 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:
@@ -113,82 +130,101 @@ A function type with a *cv-qualifier-seq* or a *ref-qualifier*
 - 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]]).
 ``` 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
 ```
 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. a function type that has a
-*cv-qualifier-seq* is not a cv-qualified type; there are no cv-qualified
-function types.
 ``` cpp
 typedef void F();
 struct S {
   const F f;        // OK: equivalent to: void f();
 };
 ```
-The return type, the parameter-type-list, the *ref-qualifier*, and the
-*cv-qualifier-seq*, but not the default arguments ([[dcl.fct.default]])
-or the exception specification ([[except.spec]]), are part of the
-function type. Function types are checked during the assignments and
 initializations of pointers to functions, references to functions, and
-pointers to member functions.
-the declaration
 ``` cpp
 int fseek(FILE*, long, int);
 ```
 declares a function taking three arguments of the specified types, and
 returning `int` ([[dcl.type]]).
-If the type of a parameter includes a type of the form “pointer to array
-of unknown bound of `T`” or “reference to array of unknown bound of
-`T`,” the program is ill-formed.[^10] 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 class type (possibly cv-qualified) unless the function is
-deleted ([[dcl.fct.def.delete]]) or the definition is nested within the
-*member-specification* for that class (including definitions in nested
-classes defined within the class).
 A typedef of function type may be used to declare a function but shall
 not be used to define a function ([[dcl.fct.def]]).
 ``` cpp
 typedef void F();
 F  fv;              // OK: equivalent to void fv();
 F  fv { }           // ill-formed
 void fv() { }       // OK: definition of fv
 ```
 An identifier can optionally be provided as a parameter name; if present
-in a function definition ([[dcl.fct.def]]), it names a parameter. 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]]).
-the declaration
 ``` cpp
 int i,
     *pi,
     f(),
@@ -208,13 +244,19 @@ The binding of `*fpi(int)` is `*(fpi(int))`, so the declaration
 suggests, and the same construction in an expression requires, the
 calling of a function `fpi`, and then using indirection through the
 (pointer) result to yield an integer. In the declarator
 `(*pif)(const char*, const char*)`, the extra parentheses are necessary
 to indicate that indirection through a pointer to a function yields a
-function, which is then called. 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);
 ```
@@ -236,21 +278,30 @@ rather than
 ``` cpp
 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. A function template is not a function.
 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]]). Otherwise, the
-*parameter-declaration* is part of a *template-parameter-list* and the
-parameter pack is a template parameter pack; see  [[temp.param]]. A
-function parameter pack is a pack expansion ([[temp.variadic]]).
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
@@ -259,12 +310,14 @@ float subtract(int, int);
 void g() {
   f(add, subtract);
 }
 ```
 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*.[^11]

 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
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
 The *parameter-declaration-clause* determines the arguments that can be
+specified, and their processing, when the function is called.
+[*Note 1*:  The *parameter-declaration-clause* is used to convert the
+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
 ``` cpp
 int printf(const char*, ...);
 ```
 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*]
 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 *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
 ```
+— *end example*]
 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]]), 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);
 ```
 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
 ``` cpp
 int i,
     *pi,
     f(),
 suggests, and the same construction in an expression requires, the
 calling of a function `fpi`, and then using indirection through the
 (pointer) result to yield an integer. In the declarator
 `(*pif)(const char*, const char*)`, the extra parentheses are necessary
 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);
 ```
 ``` cpp
 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*]
 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);
 void g() {
   f(add, subtract);
 }
 ```
+— *end example*]
 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]

Diff to HTML by rtfpessoa