函数声明

如在声明中所提及的，声明符可以后随 requires 子句，它声明该函数所关联的制约，而重载决议所要选择的函数必须满足该制约。（例如 void f1(int a) requires true;）注意，关联的制约是函数签名的一部分，但不是函数类型的一部分。

以 volatile 限定的对象类型为形参类型或返回类型是被弃用的。

与任何声明相同，出现于声明之前的属性和声明符中直接跟在标识符之后的属性，都应用于所声明或定义的实体（在此例中，应用到函数）

[[noreturn]] void f [[noreturn]] (); // OK：两个属性都应用到函数 f

然而，（语法上）出现于声明符之后的属性，应用到函数类型，而非函数自身

void f() [[noreturn]]; // 错误：此属性对效果无作用

返回类型推导

若函数声明的 声明说明符序列 包含关键词 auto，则尾随返回类型可以省略，而编译器将从 return 语句中所用的表达式的类型推导出它。若返回类型使用的不是 decltype(auto)，则推导遵循模板实参推导的规则进行。

int x = 1;
auto f() { return x; } // 返回类型是 int
const auto& f() { return x; } // 返回类型是 const int&

若返回类型是 decltype(auto)，则返回类型为将 return 语句中所用的表达式包裹于 decltype 中时所得到的类型。

int x = 1;
decltype(auto) f() { return x; } // 返回类型是 int，同 decltype(x)
decltype(auto) f() { return(x); } // 返回类型是 int&，同 decltype((x))

（注意：“const decltype(auto)&”是错误的，decltype(auto) 必须独自使用）

若有多条返回语句，则它们必须推导出相同类型

auto f(bool val)
{
    if(val) return 123; // 推导返回类型 int
    else    return 3.14f; // 错误：推导返回类型 float
}

若无 return 语句或若 return 语句的实参是 void 表达式，则所声明的返回类型，必须要么是 decltype(auto)，此情况中推导返回类型是 void，要么是（可有 cv 限定的）auto，此情况中推导的返回类型则是（同一 cv 限定的）void。

auto f() {} // 返回 void
auto g() { return f(); } // 返回 void
auto* x() {} // 错误: 不能从 void 推导 auto*

一旦在函数中见到一条 return 语句，则从该语句推导的返回类型就可用于函数的剩余部分，包括其他 return 语句。

auto sum(int i)
{
    if(i == 1)
        return i; // sum 的返回类型是 int
    else
        return sum(i - 1) + i; // OK，sum 的返回类型已知
}

若 return 语句使用花括号初始化器列表（brace-init-list），则不允许推导：

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

虚函数不能使用返回类型推导。

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

若函数使用返回类型推导，则它不能用其推导的类型或其他种类的返回类型推导再声明，即使推导出相同类型也是如此

auto f();               // 已声明，未定义
auto f() { return 42; } // 已定义，返回类型是 int
int f();                // 错误：不能使用推导的类型
decltype(auto) f();     // 错误：不同种类的推导
auto f();               // OK：再声明
 
template<typename T>
struct A { friend T frf(T); };
auto frf(int i) { return i; } // 不是 A<int> 的友元

除了用户定义转换函数以外的函数模板可以使用返回类型推导。即使 return 语句中的表达式并非待决的，推导也在实例化时发生。这种实例化并不处于 SFINAE 的目的的立即语境中。

template<class T> auto f(T t) { return t; }
typedef decltype(f(1)) fint_t; // 实例化 f<int> 以推导返回类型
template<class T> auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &f; } // 实例化两个 f 以确定返回类型，
                                  // 选择第二个模板重载

使用返回类型推导的函数模板特化必须使用同一返回类型占位符

template<typename T> auto g(T t) { return t; } // #1
template auto g(int);      // OK，返回类型是 int
//template char g(char);   // 错误，无匹配的模板
 
template<> auto g(double); // OK，用未知返回类型的前置声明
template<typename T> T g(T t) { return t; } // OK，不等价于 #1
template char g(char);     // OK，现在有匹配的模板
template auto g(float);    // 仍然匹配 #1
// void h() { return g(42); } // 错误，歧义

显式实例化声明自身并不实例化使用返回类型推导的函数模板

template<typename T> auto f(T t) { return t; }
extern template auto f(int); // 不实例化 f<int>
int (*p)(int) = f; // 实例化 f<int> 以确定其返回类型，
                   // 但仍需要在程序的别处出现显式实例化的定义

若任何函数形参使用了占位符（placeholder）（auto 或 概念（concept）类型），则函数声明转变为简写函数模板声明：

void f1(auto);    // 同 template<class T> void f(T)
void f2(C1 auto); // 同 template<C1 T> void f7(T)，若 C1 是概念

指示可变实参的省略号前不能有逗号，即使它跟随指示形参包展开的省略号也是如此，故下列函数模板是确切相同的：

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

使用这种声明的例子之一是 std::is_function 的实现。

弃置函数

如果取代函数体而使用特殊语法 = delete ;，则该函数被定义为弃置的（deleted）。任何弃置函数的使用都是非良构的（程序无法编译）。这包含调用，包括显式（以函数调用运算符）及隐式（对弃置的重载运算符、特殊成员函数、分配函数等的调用），构成指向弃置函数的指针或成员指针，甚或是在不求值表达式中使用弃置函数。但是，允许隐式 ODR 式使用 刚好被弃置的非纯虚成员函数。

若函数被重载，则首先进行重载决议，且仅当选择了弃置函数时程序才非良构。

struct sometype
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete;
};
sometype* p = new sometype; // 错误：尝试调用弃置的 sometype::operator new

函数的弃置定义必须是翻译单元中的首条声明：已经声明过的函数不能声明为弃置的：

struct sometype { sometype(); };
sometype::sometype() = delete; // 错误：必须在首条声明弃置

__func__

在函数体内，如同以如下方式定义了函数局部的预定义变量 __func__

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

此变量具有块作用域及静态存储期：

struct S
{
    S(): s(__func__) {} // OK：初始化器列表是函数体的一部分
    const char* s;
};
void f(const char* s = __func__); // 错误：形参列表是声明符的一部分