Declaring functions

noptr-declarator ( parameter-list ) cv(optional) ref(optional) except(optional) attr(optional) requires(concepts TS)

(1)

?

noptr-declarator

-

any valid declarator, but if it begins with *, &, or &&, it has to be surrounded by parentheses.

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 a type

(since C++11)

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; // deduces return type float: error } 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; // OK, 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(); // re-declared, OK 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); // OK, return type is int //template char g(char); // error, no matching template template<> auto g(double); // OK, forward declaration with unknown return type template<typename T> T g(T t) { return t; } // OK, not equivalent to #1 template char g(char); // OK, 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

(since C++14)

attr(optional) decl-specifier-seq declarator

(1)

?

If any of the function parameters uses a placeholder (either auto or a constrained type), the function declaration is instead an abbreviated function template declaration: void f(auto (auto::*)(auto)); // #1 template<typename T, typename U, typename V> void f(T (U::*)(V)); // same as #1 void g1(const C1*, C2&); // #2 (assuming C1 and C2 are concepts template<C1 T, C2 U> void g1(const T*, U&); // same as #2

(concepts TS)

Parameter type cannot be a type that includes a reference or a pointer to array of unknown bound, including a multi-level pointers/arrays of such types, or a pointer to functions whose parameters are such types

(until C++14)

attr(optional) decl-specifier-seq(optional) declarator virt-specifier-seq(optional) function-body

?

?

ctor-initializer(optional) compound-statement

(1)

?

attr(C++11)

-

optional list of attributes. These attributes are combined with the attributes after the identifier in the declarator (see top of this page), if any.

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

(since C++11)

DR

Applied to

Behavior as published

Correct behavior