Function declaration

dynamic exception specification

either dynamic exception specification
or noexcept specification

noexcept specification

As mentioned in Declarations, the declarator can be followed by a requires clause, which declares the associated constraints for the function, which must be satisfied in order for the function to be selected by overload resolution. (example: void f1(int a) requires true;) Note that the associated constraint is part of function signature, but not part of function type.

Using a volatile-qualified object type as parameter type or return type is deprecated.

As with any declaration, attributes that appear before the declaration and the attributes that appear immediately after the identifier within the declarator both apply to the entity being declared or defined (in this case, to the function):

[[noreturn]] void f [[noreturn]] (); // OK: both attributes apply to the function f

However, the attributes that appear after the declarator (in the syntax above), apply to the type of the function, not to the function itself:

void f() [[noreturn]]; // Error: this attribute has no effect on the function itself

Return type deduction

If the decl-specifier-seq of the function declaration contains the keyword auto, trailing return type may be omitted, and will be deduced by the compiler from the type of the operand used in the non-discarded return statement. If the return type does not use decltype(auto), the deduction follows the rules of template argument deduction:

int x = 1;
auto f() { return x; } // return type is int
const auto& f() { return x; } // return type is const int&

If the return type is decltype(auto), the return type is as what would be obtained if the operand used in the return statement were wrapped in decltype:

int x = 1;
decltype(auto) f() { return x; } // return type is int, same as decltype(x)
decltype(auto) f() { return(x); } // return type is int&, same as decltype((x))

(note: "const decltype(auto)&" is an error, decltype(auto) must be used on its own)

If there are multiple return statements, they must all deduce to the same type:

auto f(bool val)
{
 if (val) return 123; // deduces return type int
 else return 3.14f; // Error: deduces return type float
}

If there is no return statement or if the operand of the return statement is a void expression (including return statements with no operand), the declared return type must be either decltype(auto), in which case the deduced return type is void, or (possibly cv-qualified) auto, in which case the deduced return type is then (identically cv-qualified) void:

auto f() {} // returns void
auto g() { return f(); } // returns void
auto* x() {} // Error: cannot deduce auto* from void

Once a return statement has been seen in a function, the return type deduced from that statement can be used in the rest of the function, including in other return statements:

auto sum(int i)
{
 if (i == 1)
 return i; // sum’s return type is int
 else
 return sum(i - 1) + i; // OK: sum’s return type is already known
}

If the return statement uses a brace-enclosed initializer list, deduction is not allowed:

auto func() { return {1, 2, 3}; } // Error

Virtual functions and coroutines (since C++20) cannot use return type deduction:

struct F
{
 virtual auto f() { return 2; } // Error
};

Function templates other than user-defined conversion functions can use return type deduction. The deduction takes place at instantiation even if the expression in the return statement is not dependent. This instantiation is not in an immediate context for the purposes of SFINAE.

template<class T>
auto f(T t) { return t; }
typedef decltype(f(1)) fint_t; // instantiates f<int> to deduce return type
 
template<class T>
auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &f; } // instantiates both fs to determine return types,
 // chooses second template overload

Redeclarations or specializations of functions or function templates that use return type deduction must use the same return type placeholders:

auto f(int num) { return num; }
// int f(int num); // Error: no placeholder return type
// decltype(auto) f(int num); // Error: different placeholder
 
template<typename T>
auto g(T t) { return t; }
template auto g(int); // OK: return type is int
// template char g(char); // Error: not a specialization of the primary template g

Similarly, redeclarations or specializations of functions or function templates that do not use return type deduction must not use a placeholder:

int f(int num);
// auto f(int num) { return num; } // Error: not a redeclaration of f
 
template<typename T>
T g(T t) { return t; }
template int g(int); // OK: specialize T as int
// template auto g(char); // Error: not a specialization of the primary template g

Explicit instantiation declarations do not themselves instantiate function templates that use return type deduction:

template<typename T>
auto f(T t) { return t; }
extern template auto f(int); // does not instantiate f<int>
 
int (*p)(int) = f; // instantiates f<int> to determine its return type,
 // but an explicit instantiation definition 
 // is still required somewhere in the program

attr (optional) this decl-specifier-seq declarator

attr (optional) this decl-specifier-seq abstract-declarator (optional)

Although decl-specifier-seq implies there can exist specifiers other than type specifiers, the only other specifier allowed is register as well as auto(until C++11), and it has no effect.

If any of the function parameters uses a placeholder (either auto or a concept type), the function declaration is instead an abbreviated function template declaration:

void f1(auto); // same as template<class T> void f1(T)
void f2(C1 auto); // same as template<C1 T> void f2(T), if C1 is a concept

A parameter declaration with the specifier this (syntax (2)/(5)) declares an explicit object parameter.

An explicit object parameter cannot be a function parameter pack, and it can only appear as the first parameter of the parameter list in the following declarations:

• a declaration of a member function or member function template
• an explicit instantiation or explicit specialization of a templated member function
• a lambda declaration

A member function with an explicit object parameter has the following restrictions:

• The function is not static.
• The function is not virtual.
• The declarator of the function does not contain cv and ref.

struct C
{
 void f(this C& self); // OK
 
 template<typename Self>
 void g(this Self&& self); // also OK for templates
 
 void p(this C) const; // Error: "const" not allowed here
 static void q(this C); // Error: "static" not allowed here
 void r(int, this C); // Error: an explicit object parameter
 // can only be the first parameter
};
 
// void func(this C& self); // Error: non-member functions cannot have
 // an explicit object parameter

• 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".

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 ".

• The(until C++17)Otherwise, the(since C++17) 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.

• 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.

If a function definition contains a virt-specs, it must define a member function.

If a function definition contains a requires-clause, it must define a templated function.

Defaulted functions

If the function definition 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 (since C++20), 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 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.

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

If the function definition is of syntax (4) or (5)(since C++26), 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 the function is overloaded, overload resolution takes place first, and the program is only ill-formed if the deleted function was selected:

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:

struct T { T(); };
T::T() = delete; // Error: must be deleted on the first declaration

User-provided functions

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.

// 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

In the case of an ambiguity between a function body and an initializer beginning with { or =(since C++26), 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.

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__

Within the function body, the function-local predefined variable __func__ is defined as if by

static const char __func__[] = "function-name";

This variable has block scope and static storage duration:

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

#include <iostream>
 
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;
}

Foo Bar Pub ~Bar

Function contract specifiers

Function declarations and lambda expressions can contain a sequence of function contract specifiers , each specifier has the following syntax:

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:

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.

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:

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:

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.

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
}

[edit] Notes

In case of ambiguity between a variable declaration using the direct-initialization syntax and a function declaration, the compiler always chooses function declaration; see direct-initialization.

[edit] Keywords

default, delete, pre, post

[edit] Example

#include <iostream>
#include <string>
 
// simple function with a default argument, returning nothing
void f0(const std::string & arg = "world!")
{
 std::cout << "Hello, " << arg << '\n';
}
 
// the declaration is in namespace (file) scope
// (the definition is provided later)
int f1();
 
// function returning a pointer to f0, pre-C++11 style
void (*fp03())(const std::string &)
{
 return f0;
}
 
// function returning a pointer to f0, with C++11 trailing return type
auto fp11() -> void(*)(const std::string &)
{
 return f0;
}
 
int main()
{
 f0();
 fp03()("test!");
 fp11()("again!");
 int f2(std::string ) noexcept; // declaration in function scope
 std::cout << "f2(\"bad\"): " << f2("bad") << '\n';
 std::cout << "f2(\"42\"): " << f2("42") << '\n';
}
 
// simple non-member function returning int
int f1()
{
 return 007;
}
 
// function with an exception specification and a function try block
int f2(std::string str) noexcept
try
{
 return std::stoi (str);
}
catch (const std::exception & e)
{
 std::cerr << "stoi() failed!\n";
 return 0;
}
 
// deleted function, an attempt to call it results in a compilation error
void bar() = delete
# if __cpp_deleted_function
 ("reason")
# endif
;

stoi() failed!
Hello, world!
Hello, test!
Hello, again!
f2("bad"): 0
f2("42"): 42

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also