+void f(Args......); // same as above, but deprecated since C++26
+```
+
+## Function type
+
+### Parameter-type-list
+
+A function’s _parameter-type-list_ is determined as follows:
+
+1. The type of each parameter (including function parameter packs) is determined from its own parameter declaration.
+2. 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”.
+3. After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type.
+4. 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.
+
+```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
+```
+
+### Determining function type
+
+In syntax (1), assuming `noptr-declarator` as a standalone declaration, given the type of the `qualified-id` or `unqualified-id` in `noptr-declarator` as “derived-declarator-type-list T”:
+
+
+ - If the exception specification is non-throwing, the type of the function declared is “derived-declarator-type-list `noexcept` function of parameter-type-list `cv` (optional) `ref` (optional) returning T”.
+
+
+- TheOtherwise, the type of the function declared is “derived-declarator-type-list function of parameter-type-list `cv` (optional) `ref` (optional) returning T”.
+
+
+ In syntax (2), assuming `noptr-declarator` as a standalone declaration, given the type of the `qualified-id` or `unqualified-id` in `noptr-declarator` as “derived-declarator-type-list T” (T must be `auto` in this case):
+
+
+
+ - If the exception specification is non-throwing, the type of the function declared is “derived-declarator-type-list `noexcept` function of parameter-type-list `cv` (optional) `ref` (optional) returning `trailing`”.
+
+
+
+ - TheOtherwise, the type of the function declared is “derived-declarator-type-list function of parameter-type-list `cv` (optional) `ref` (optional) returning `trailing`”.
+
+ `attr`, if present, applies to the function type.
+
+
+```cpp
+// the type of “f1” is
+// “function of int returning void, with attribute noreturn”
+void f1(int a) [[noreturn]];
+
+// the type of “f2” is
+// “constexpr noexcept function of pointer to int returning int”
+constexpr auto f2(int[] b) noexcept -> int;
+
+struct X {
+ // the type of “f3” is
+ // “function of no parameter const returning const int”
+ const int f3() const;
+};
+```
+
+### Trailing qualifiers
+
+A function type with `cv` or `ref` (including a type named by typedef name) can 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 template type parameter, or
+- the type-id of a template argument for a template type parameter.
+
+```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
+```
+
+## Function signature
+
+Every function has a signature.
+
+The signature of a function consists of its name and parameter-type-list. Its signature also contains the enclosing namespace, with the following exceptions:
+
+- If the function is a member function, its signature contains the class of which the function is a member instead of the enclosing namespace. Its signature also contains the following components, if exists:
+ - `cv`
+
+ - `ref`
+
+
+ - trailing requires clause
+
+
+
+ - If the function is a non-template friend function with a trailing requires clause, its signature contains the enclosing class instead of the enclosing namespace. The signature also contains the trailing requires clause.
+
+
+`except` and `attr` doesn't involve function signature, although noexcept specification affects the function type.
+
+## Function definition
+
+A non-member function definition may appear at namespace scope only (there are no nested functions). A member function definition may also appear in the body of a class definition. They have the following syntax:
+
+
+
+
+ ```cpp
+ /* decl-specifier-seq (optional) */
+ /* declarator */
+ /* function-body */
+ ```
+
+
+
+
+ ```cpp
+ /* attr (optional) */
+ /* decl-specifier-seq (optional) */
+ /* declarator */
+ /* virt-specs (optional) */
+ /* function-body */
+ ```
+
+
+
+
+ ```cpp
+ /* attr (optional) */
+ /* decl-specifier-seq (optional) */
+ /* declarator */
+ /* virt-specs (optional) */
+ /* contract-specs (optional) */
+ /* function-body */
+ ```
+
+
+
+ A function definition without constraints.
+
+
+
+
+
+ ```cpp
+ /* attr (optional) */
+ /* decl-specifier-seq (optional) */
+ /* declarator */
+ /* require-clause */
+ /* function-body */
+ ```
+
+
+
+
+ ```cpp
+ /* attr (optional) */
+ /* decl-specifier-seq (optional) */
+ /* declarator */
+ /* require-clause */
+ /* contract-specs (optional) */
+ /* function-body */
+ ```
+
+
+
+ A function definition with constraints.
+
+
+
+
+ the return type with specifiers, as in the declaration grammar
+
+
+ function declarator, same as in the function declaration grammar above (can be parenthesized)
+
+
+ the function body (see below)
+
+
+
+
+
+
+ a list of attributes. These attributes are combined with the attributes after the identifier in the `declarator` (see top of this page), if any.
+
+
+ override, final, or their combination in any order
+
+
+
+
+
+
+
+ a requires clause
+
+
+
+
+
+
+
+ a list of function contract specifiers
+
+
+
+
+`function-body` is one of the following:
+
+
+
+ ```cpp
+ /* ctor-initializer (optional) */
+ /* compound-statement */
+ ```
+
+
+ Regular function body.
+
+
+
+
+ ```cpp
+ /* function-try-block */
+ ```
+
+
+ Function try block.
+
+
+
+
+
+ ```cpp
+ = default ;
+ ```
+
+
+
+ Explicitly defaulted function definition.
+
+
+
+
+
+ ```cpp
+ = delete ;
+ ```
+
+
+
+ Explicitly deleted function definition.
+
+
+
+
+
+ ```cpp
+ = delete (/* string-literal */);
+ ```
+
+
+
+ Explicitly deleted function definition with error message.
+
+
+
+
+ member initializer list, only allowed in constructors
+
+
+ the brace-enclosed sequence of statements that constitutes the body of a function
+
+
+ a function try block
+
+
+
+
+
+
+ an unevaluated string literal that could be used to explain the rationale for why the function is deleted
+
+
+
+
+```cpp
+int max(int a, int b, int c) {
+ int m = (a > b) ? a : b;
+ return (m > c) ? m : c;
+}
+
+// decl-specifier-seq is “int”
+// declarator is “max(int a, int b, int c)”
+// body is { ... }
+```
+
+The function body is a compound statement (sequence of zero or more statements surrounded by a pair of curly braces), which is executed when the function call is made. Moreover, the function body of a constructor also includes the following:
+
+- For all non-static data members whose identifiers are absent in the constructor's member initializer list, the default member initializers or default-initializations used to initialize the corresponding member subobjects.
+- For all base classes whose type names are absent in the constructor's member initializer list, the default-initializations used to initialize the corresponding base class subobjects.
+
+
+ If a function definition contains a `virt-specs`, it must define a member function.
+
+ ```cpp
+ void f() override {} // Error: not a member function
+ ```
+
+
+
+ If a function definition contains a `requires-clause`, it must define a templated function.
+
+ ```cpp
+ void g() requires (sizeof(int) == 4) {} // Error: not a templated function
+ ```
+
+
+The parameter types, as well as the return type of a function definition cannot be (possibly cv-qualified) incomplete class types unless the function is defined as deleted. The completeness check is only made in the function body, which allows member functions to return the class in which they are defined (or its enclosing class), even if it is incomplete at the point of definition (it is complete in the function body).
+
+The parameters declared in the `declarator` of a function definition are in scope within the body. If a parameter is not used in the function body, it does not need to be named (it's sufficient to use an abstract declarator):
+
+```cpp
+void print(int a, int) // second parameter is not used
+{
+ std::printf("a = %d\n", a);
+}
+```
+
+Even though top-level cv-qualifiers on the parameters are discarded in function declarations, they modify the type of the parameter as visible in the body of a function:
+
+```cpp
+void f(const int n) // declares function of type void(int)
+{
+ // but in the body, the type of “n” is const int
+}
+```
+
+
+ ### Defaulted functions :badge[C++11]
+
+ If `function-body` is of syntax (3), the function is defined as _explicitly defaulted_.
+
+ A function that is explicitly defaulted must be a special member function or comparison operator function, and it must have no default argument.
+
+ An explicitly defaulted special member function F1 is allowed to differ from the corresponding special member function F2 that would have been implicitly declared, as follows:
+
+ - F1 and F2 may have different `ref` and/or `except`.
+ - If F2 has a non-object parameter of type `const C&`, the corresponding non-object parameter of F1 maybe of type `C&`.
+
+
+ - If F2 has an implicit object parameter of type “reference to C”, F1 may be an explicit object member function whose explicit object parameter is of (possibly different) type “reference to C”, in which case the type of F1 would differ from the type of F2 in that the type of F1 has an additional parameter.
+
+
+ If the type of F1 differs from the type of F2 in a way other than as allowed by the preceding rules, then:
+
+ - If F1 is an assignment operator, and the return type of F1 differs from the return type of F2 or F1’s non-object parameter type is not a reference, the program is ill-formed.
+ - Otherwise, if F1 is explicitly defaulted on its first declaration, it is defined as deleted.
+ - Otherwise, the program is ill-formed.
+
+ A function explicitly defaulted on its first declaration is implicitly inline, and is implicitly constexpr if it can be a constexpr function.
+
+ ```cpp
+ struct S {
+ S(int a = 0) = default; // error: default argument
+ void operator=(const S&) = default; // error: non-matching return type
+ ~S() noexcept(false) = default; // OK, different exception specification
+ private:
+ int i;
+ S(S&); // OK, private copy constructor
+ };
+
+ S::S(S&) = default; // OK, defines copy constructor
+ ```
+
+ Explicitly-defaulted functions and implicitly-declared functions are collectively called _defaulted_ functions. Their actual definitions will be implicitly provided, see their corresponding pages for details.
+
+ ### Deleted functions :badge[C++11]
+
+ If `function-body` is of syntax (4) or (5), the function is defined as _explicitly deleted_.
+
+ Any use of a deleted function is ill-formed (the program will not compile). This includes calls, both explicit (with a function call operator) and implicit (a call to deleted overloaded operator, special member function, allocation function, etc), constructing a pointer or pointer-to-member to a deleted function, and even the use of a deleted function in an expression that is not potentially-evaluated.
+
+ A non-pure virtual member function can be defined as deleted, even though it is implicitly odr-used. A deleted function can only be overridden by deleted functions, and a non-deleted function can only be overridden by non-deleted functions.
+
+
+ If `string-literal` is present, the implementation is encouraged to include the text of it as part of the resulting diagnostic message which shows the rationale for deletion or to suggest an alternative.
+
+
+ If the function is overloaded, overload resolution takes place first, and the program is only ill-formed if the deleted function was selected:
+
+ ```cpp
+ struct T {
+ void* operator new(std::size_t) = delete;
+ void* operator new[](std::size_t) = delete("new[] is deleted"); // since C++26
+ };
+
+ T* p = new T; // Error: attempts to call deleted T::operator new
+ T* p = new T[5]; // Error: attempts to call deleted T::operator new[],
+ // emits a diagnostic message “new[] is deleted”
+ ```
+
+ The deleted definition of a function must be the first declaration in a translation unit: a previously-declared function cannot be redeclared as deleted:
+
+ ```cpp
+ struct T { T(); };
+ T::T() = delete; // Error: must be deleted on the first declaration
+ ```
+
+ ### User-provided functions :badge[C++11]
+
+ A function is _user-provided_ if it is user-declared and not explicitly defaulted or deleted on its first declaration. A user-provided explicitly-defaulted function (i.e., explicitly defaulted after its first declaration) is defined at the point where it is explicitly defaulted; if such a function is implicitly defined as deleted, the program is ill-formed. Declaring a function as defaulted after its first declaration can provide efficient execution and concise definition while enabling a stable binary interface to an evolving code base.
+
+ ```cpp
+ // All special member functions of “trivial” are
+ // defaulted on their first declarations respectively,
+ // they are not user-provided
+ struct trivial {
+ trivial() = default;
+ trivial(const trivial&) = default;
+ trivial(trivial&&) = default;
+ trivial& operator=(const trivial&) = default;
+ trivial& operator=(trivial&&) = default;
+ ~trivial() = default;
+ };
+
+ struct nontrivial {
+ nontrivial(); // first declaration
+ };
+
+ // not defaulted on the first declaration,
+ // it is user-provided and is defined here
+ nontrivial::nontrivial() = default;
+ ```
+
+ ### Ambiguity Resolution :badge[C++11]
+
+ In the case of an ambiguity between a function body and an initializer beginning with `{` or `=`, the ambiguity is resolved by checking the type of the declarator identifier of `noptr-declarator`:
+
+ - If the type is a function type, the ambiguous token sequence is treated as a function body.
+ - Otherwise, the ambiguous token sequence is treated as an initializer.
+
+ ```cpp
+ using T = void(); // function type
+ using U = int; // non-function type
+
+ T a{}; // defines a function doing nothing
+ U b{}; // value-initializes an int object
+
+ T c = delete("hello"); // defines a function as deleted
+ U d = delete("hello"); // copy-initializes an int object with
+ // the result of a delete expression (ill-formed)
+ ```
+
+ ### \_\_func\_\_ :badge[C++11]
+
+ Within the function body, the function-local predefined variable `__func__` is defined as if by
+
+ ```cpp
+ static const char __func__[] = "function-name";
+ ```
+
+ This variable has block scope and static storage duration:
+
+ ```cpp
+ struct S {
+ S(): s(__func__) {} // OK: initializer-list is part of function body
+ const char* s;
+ };
+ void f(const char* s = __func__); // Error: parameter-list is part of declarator
+ ```
+
+ ```cpp
+ #include
+
+ void Foo() { std::cout << __func__ << ' '; }
+
+ struct Bar {
+ Bar() { std::cout << __func__ << ' '; }
+ ~Bar() { std::cout << __func__ << ' '; }
+ struct Pub { Pub() { std::cout << __func__ << ' '; } };
+ };
+
+ int main() {
+ Foo();
+ Bar bar;
+ Bar::Pub pub;
+ }
+ ```
+
+ Possible output:
+
+ ```
+ Foo Bar Pub ~Bar
+ ```
+
+
+
+ ## Function contract specifier :badge[C++26]
+
+ Function declarations and
lambda expressions can contain a sequence of _function contract specifiers_, each specifier has the following syntax:
+
+
+
+ ```cpp
+ pre /* attr (optional) */ (/* predicate */)
+ ```
+
+
+ Introduces a _precondition assertion_.
+
+
+
+
+ ```cpp
+ post /* attr (optional) */ (/* predicate */)
+ ```
+
+
+ Introduces a _postcondition assertion_ in which the assertion does not bind to the result.
+
+
+
+
+ ```cpp
+ post /* attr (optional) */ (/* identifier */ /* result-attr (optional) */ : /* predicate */)
+ ```
+
+
+ Introduces a _postcondition assertion_ in which the assertion binds to the result.
+
+
+
+
+ a list of attributes appertaining to the introduced contract assertion
+
+
+ any expression (except unparenthesized comma expressions)
+
+
+ the identifier that refers to the result
+
+
+ a list of attributes appertaining to the result binding
+
+
+
+ Precondition assertion and postcondition assertion are collectively called _function contract assertion_.
+
+ A function contract assertion is a
contract assertion associated with a function. The predicate of a function contract assertion is its `predicate`
contextually converted to `bool`.
+
+ The following functions cannot be declared with function contract specifiers:
+
+ -
virtual functions
+ -
deleted functions
+ - function
defaulted on their first declarations
+
+ ### Precondition assertions
+
+ A precondition assertion is associated with entering a function:
+
+ ```cpp
+ int divide(int dividend, int divisor) pre(divisor != 0) {
+ return dividend / divisor;
+ }
+
+ double square_root(double num) pre(num >= 0) {
+ return std::sqrt(num);
+ }
+ ```
+
+ ### Postcondition assertions
+
+ A postcondition assertion is associated with exiting a function normally.
+
+ If a postcondition assertion has an `identifier`, the function contract specifier introduces `identifier` as the name of a _result binding_ of the associated function. A result binding denotes the object or reference returned by invocation of that function. The type of a result binding is the return type of its associated function.
+
+ ```cpp
+ int absolute_value(int num) post(r : r >= 0) {
+ return std::abs(num);
+ }
+
+ double sine(double num) post(r : r >= -1.0 && r <= 1.0) {
+ if (std::isnan(num) || std::isinf(num))
+ // exiting via an exception never causes contract violation
+ throw std::invalid_argument("Invalid argument");
+ return std::sin(num);
+ }
+ ```
+
+ If a postcondition assertion has an `identifier`, and the return type of the associated function is (possibly cv-qualified) `void`, the program is
ill-formed:
+
+ ```cpp
+ void f() post(r : r > 0); // Error: no value can be bound to “r”
+ ```
+
+ When the declared return type of a non-templated function contains a
placeholder type, a postcondition assertion with an `identifier` can only appear in a function definition:
+
+ ```cpp
+ auto g(auto&) post(r : r >= 0); // OK, “g” is a template
+
+ auto h() post(r : r >= 0); // Error: cannot name the return value
+
+ auto k() post(r : r >= 0) // OK, “k” is a definition
+ {
+ return 0;
+ }
+ ```
+
+ ### Contract consistency
+
+ A
redeclaration D of a function or function template `func` must have either no `contract-specs` or the same contract-specs as any first declaration F reachable from D. If D and F are in different translation units, a diagnostic is required only if D is attached to a named module.
+
+ If a declaration F1 is a first declaration of func in one translation unit and a declaration F2 is a first declaration of `func` in another translation unit, F1 and F2 must specify the same `contract-specs`, no diagnostic required.
+
+ Two `contract-specs`s are the same if they consist of the same function contract specifiers in the same order.
+
+ A function contract specifier C1 on a function declaration D1 is the same as a function contract specifier C2 on a function declaration D2 if all following conditions are satisfied:
+
+ - The `predicate`s of C1 and C2 would satisfy the
one-definition rule if placed in function definitions on the declarations D1 and D2 (if D1 and D2 are in different translation units, corresponding entities defined within each `predicate` behave as if there is a single entity with a single definition), respectively, except for the following renamings:
+ - The renaming of the parameters of the declared function.
+ - The renaming of template parameters of a template enclosing the declared function.
+ - The renaming of the result binding (if any).
+ - Both C1 and C2 have an `identifier` or neither have.
+
+ If this condition is not met solely due to the comparison of two lambda expressions that are contained within the `predicate`s, no diagnostic is required.
+
+ ```cpp
+ bool b1, b2;
+
+ void f() pre (b1) pre([]{ return b2; }());
+ void f(); // OK, function contract specifiers omitted
+ void f() pre (b1) pre([]{ return b2; }()); // Error: closures have different types
+ void f() pre (b1); // Error: function contract specifiers are different
+
+ int g() post(r : b1);
+ int g() post(b1); // Error: no result binding
+
+ namespace N {
+ void h() pre (b1);
+ bool b1;
+ void h() pre (b1); // Error: function contract specifiers differ
+ // according to the one−definition rule
+ }
+ ```
+
+ ## Alternatives :badge[C++11]
+
+ - Variadic templates can also be used to create functions that take variable number of arguments. They are often the better choice because they do not impose restrictions on the types of the arguments, do not perform integral and floating-point promotions, and are type safe.
+ - If all variable arguments share a common type, a `std::initializer_list` provides a convenient mechanism (albeit with a different syntax) for accessing variable arguments. In this case however the arguments cannot be modified since `std::initializer_list` can only provide a const pointer to its elements.
+
+
+## Notes
+
+In the C programming language until C23, at least one named parameter must appear before the ellipsis parameter, so `R printz(...);` is not valid until C23. In C++, this form is allowed even though the arguments passed to such function are not accessible, and is commonly used as the fallback overload in SFINAE, exploiting the lowest priority of the ellipsis conversion in overload resolution.
+
+This syntax for variadic arguments was introduced in 1983 C++ without the comma before the ellipsis. When C89 adopted function prototypes from C++, it replaced the syntax with one requiring the comma. For compatibility, C++98 accepts both C++-style `f(int n...)` and `C-style f(int n, ...)`. The original C++-style grammar is deprecated since C++26.
+
+
+ The comma can be used in abbreviated function templates to make the ellipsis signify a variadic function instead of a variadic template:
+
+ ```cpp
+ void f1(auto...); // same as template void f3(Ts...)
+ void f2(auto, ...); // same as template void f3(T, ...)
+ ```
+
+
+## Defect reports
+
+The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
+
+
+
+
+ passing non-POD class arguments to an ellipsis resulted in undefined behavior
+
+
+ passing such arguments is conditionally-supported with implementation-defined semantics
+
+
+
+
+
+ conditionally-supported class types made some SFINAE idioms not work
+
+
+ always supported if unevaluated
+
+
+
+
+
+ no restriction on passing parameter pack or lambda capture to `va_start`
+
+
+ made ill-formed, no diagnostic required
+
+
+
+
+
+ it was unclear whether scoped enumerations passed to an ellipsis are subject to default argument promotions
+
+
+ passing scoped enumerations is conditionally-supported with implementation-defined semantics
+
+
+
+
+## See also
+
+
+
+ C documentation for **Variadic arguments**
+
+
+ C documentation for **Implicit conversions**
+
+
\ No newline at end of file