• 1Function declaration
• 2Return type deduction
• 3Parameter list
  • 3.1Using an ellipsis
• 4Function type
  • 4.1Parameter-type-list
  • 4.2Determining function type
  • 4.3Trailing qualifiers
• 5Function signature
• 6Function definition
  • 6.1Defaulted functions
  • 6.2Deleted functions
  • 6.3User-provided functions
  • 6.4Ambiguity Resolution
  • 6.5__func__
• 7Function contract specifiers
  • 7.1Precondition assertions
  • 7.2Postcondition assertions
  • 7.3Contract consistency
• 8Notes
• 9Keywords
• 10Example
• 11Defect reports
• 12See also

As mentioned inDeclarations, the declarator can be followed by arequires clause, which declares the associatedconstraints for the function, which must be satisfied in order for the function to be selected byoverload resolution. (example:void f1(int a) requirestrue;) 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 thedecl-specifier-seq of the function declaration contains the keywordauto, trailing return type may be omitted, and will be deduced by the compiler from the type of the operand used in thenon-discardedreturn statement. If the return type does not usedecltype(auto), the deduction follows the rules oftemplate argument deduction:

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

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

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)return123;// deduces return type intelsereturn3.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 eitherdecltype(auto), in which case the deduced return type isvoid, or (possibly cv-qualified)auto, in which case the deduced return type is then (identically cv-qualified)void:

auto f(){}// returns voidauto g(){return f();}// returns voidauto* 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 intelsereturn sum(i-1)+ i;// OK: sum’s return type is already known}

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

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

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

struct F{virtualauto f(){return2;}// Error};

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

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;}templateauto 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;}templateint 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;}externtemplateauto 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)thisdecl-specifier-seqdeclarator

attr (optional)thisdecl-specifier-seqabstract-declarator (optional)

Althoughdecl-specifier-seq implies there can existspecifiers other than type specifiers, the only other specifier allowed isregister as well asauto(until C++11), and it has no effect.

If any of the function parameters uses aplaceholder (eitherauto or aconcept type), the function declaration is instead anabbreviated function template declaration:

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

A parameter declaration with the specifierthis (syntax(2)/(5)) declares anexplicit object parameter.

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

• a declaration of amember function or member function template
• anexplicit instantiation orexplicit specialization of a templated member function
• alambda declaration

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

• The function is notstatic.
• The function is notvirtual.
• The declarator of the function does not containcv andref.

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 herestaticvoid q(this C);// Error: “static” not allowed herevoid 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 isnon-throwing, the type of the function declared is
  “derived-declarator-type-listnoexcept function of
  parameter-type-listcv (optional)ref  (optional) returningT”.

In syntax(2), assumingnoptr-declarator as a standalone declaration, given the type of thequalified-id orunqualified-id innoptr-declarator as “derived-declarator-type-listT” (T must beauto in this case):

• If the exception specification isnon-throwing, the type of the function declared is
  “derived-declarator-type-listnoexcept function of
  parameter-type-listcv (optional)ref  (optional) returningtrailing ”.

• The(until C++17)Otherwise, the(since C++17) type of the function declared is
  “derived-declarator-type-list function of
  parameter-type-listcv (optional)ref  (optional) returningtrailing ”.

attr, if present, applies to the function type.

• ref

• trailingrequires clause

• If the function is a non-templatefriend function with a trailingrequires clause, its signature contains the enclosing class instead of the enclosing namespace. The signature also contains the trailingrequires clause.

If a function definition contains avirt-specs, it must define amember function.

If a function definition contains arequires-clause, it must define atemplated function.

Defaulted functions

If the function definition is of syntax(3), the function is defined asexplicitly defaulted.

A function that is explicitly defaulted must be aspecial member function orcomparison operator function(since C++20), and it must have nodefault argument.

An explicitly defaulted special member functionF1 is allowed to differ from the corresponding special member functionF2 that would have been implicitly declared, as follows:

• F1 andF2 may have differentref and/orexcept.
• IfF2 has a non-object parameter of typeconst C&, the corresponding non-object parameter ofF1 maybe of typeC&.

If the type ofF1 differs from the type ofF2 in a way other than as allowed by the preceding rules, then:

• IfF1 is an assignment operator, and the return type ofF1 differs from the return type ofF2 orF1’s non-object parameter type is not a reference, the program is ill-formed.
• Otherwise, ifF1 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 implicitlyinline, and is implicitly constexpr if it can be aconstexpr function.

struct S{    S(int a=0)=default;// error: default argumentvoid operator=(const S&)=default;// error: non-matching return type    ~S()noexcept(false)=default;// OK, different exception specificationprivate: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 calleddefaulted 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 asexplicitly 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 notpotentially-evaluated.

A non-pure virtual member function can be defined as deleted, even though it is implicitlyodr-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 newT* 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 isuser-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-providedstruct 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 herenontrivial::nontrivial()=default;

Ambiguity Resolution

In the case of an ambiguity between a function body and aninitializer beginning with{ or=(since C++26), the ambiguity is resolved by checking the type of thedeclarator identifier ofnoptr-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 typeusing U=int;// non-function type T a{};// defines a function doing nothingU b{};// value-initializes an int object T c= delete("hello");// defines a function as deletedU 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

staticconstchar __func__[]="function-name";

This variable has block scope and static storage duration:

struct S{    S(): s(__func__){}// OK: initializer-list is part of function bodyconstchar* s;};void f(constchar* 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 andlambda expressions can contain a sequence offunction contract specifiers , each specifier has the following syntax:

Precondition assertion and postcondition assertion are collectively calledfunction contract assertion .

A function contract assertion is acontract assertion associated with a function. The predicate of a function contract assertion is itspredicatecontextually converted tobool.

The following functions cannot be declared with function contract specifiers:

• virtual functions
• deleted functions
• functiondefaulted 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){returnstd::sqrt(num);}

Postcondition assertions

A postcondition assertion is associated with exiting a function normally.

If a postcondition assertion has anidentifier , the function contract specifier introducesidentifier as the name of aresult 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 violationthrowstd::invalid_argument("Invalid argument");returnstd::sin(num);}

If a postcondition assertion has anidentifier , 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 aplaceholder type, a postcondition assertion with anidentifier  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{return0;}

Contract consistency

AredeclarationD of a function or function templatefunc must have either nocontract-specs or the samecontract-specs as any first declarationF reachable fromD. IfD andF are in different translation units, a diagnostic is required only ifD is attached to a named module.

If a declarationF1 is a first declaration offunc in one translation unit and a declarationF2 is a first declaration offunc in another translation unit,F1 andF2 must specify the samecontract-specs , no diagnostic required.

Twocontract-specs s are the same if they consist of the same function contract specifiers in the same order.

A function contract specifierC1 on a function declarationD1 is the same as a function contract specifierC2 on a function declarationD2 if all following conditions are satisfied:

• Thepredicate s ofC1 andC2 would satisfy theone-definition rule if placed in function definitions on the declarationsD1 andD2 (ifD1 andD2 are in different translation units, corresponding entities defined within eachpredicate 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).
• BothC1 andC2 have anidentifier or neither have.

If this condition is not met solely due to the comparison of two lambda expressions thatare contained within thepredicate s, no diagnostic is required.

bool b1, b2; void f() pre(b1) pre([]{return b2;}());void f();// OK, function contract specifiers omittedvoid f() pre(b1) pre([]{return b2;}());// Error: closures have different typesvoid 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}