Function declaration

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.

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]] (); // okay: 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 a type

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 expression used in the 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 expression 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 argument of the return statement is a void expression, 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; // okay: sum’s return type is already known
}

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

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

Virtual functions cannot use return type deduction.

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

If a function uses return type deduction, it cannot be redeclared using the type that it deduces to, or another kind of return type deduction even if it deduces to the same type

auto f();               // declared, not yet defined
auto f() { return 42; } // defined, return type is int
int f();                // error: cannot use the deduced type
decltype(auto) f();     // error: different kind of deduction
auto f();               // okay: re-declared
 
template<typename T>
struct A { friend T frf(T); };
auto frf(int i) { return i; } // not a friend of A<int>

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

Specializations of function templates that use return type deduction must use the same return type placeholders

template<typename T> auto g(T t) { return t; } // #1
template auto g(int);      // okay: return type is int
//template char g(char);     // error: no matching template
 
template<> auto g(double); // okay: forward declaration with unknown return type
template<typename T> T g(T t) { return t; } // okay: not equivalent to #1
template char g(char);     // okay: now there is a matching template
template auto g(float);    // still matches #1
//void h() { return g(42); } // error: ambiguous

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

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 f(T)
void f2(C1 auto); // same as template<C1 T> void f7(T), if C1 is a concept

The ellipsis that indicates variadic arguments need not be preceded by a comma, even if it follows the ellipsis that indicates a parameter pack expansion, so the following function templates are exactly the same:

template<typename ...Args> void f(Args..., ...);
template<typename ...Args> void f(Args... ...);
template<typename ...Args> void f(Args......);

An example of when such declaration is used is the implementation of std::is_function

Deleted functions

If, instead of a function body, the special syntax = delete ; is used, the function is defined as 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 unevaluated expression. However, implicit ODR-use of a non-pure virtual member function that happens to be deleted is allowed.

If the function is overloaded, overload resolution takes place first, and the program is only ill-formed if the deleted function was selected.

struct sometype
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete;
};
sometype* p = new sometype; // error: attempts to call deleted sometype::operator new

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 sometype { sometype(); };
sometype::sometype() = delete; // error: must be deleted on the first declaration

__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__) {} // okay: initializer-list is part of function body
    const char* s;
};
void f(const char* s = __func__); // error: parameter-list is part of declarator