Function declaration

如 声明 所述， 声明符后可以跟随 requires 子句 ， 用于声明函数的关联 约束 ， 这些约束必须被满足才能通过 重载决议 选择该函数。（示例： void f1 ( int a ) requires true ; ） 注意：关联约束是函数签名的组成部分，但不属于函数类型。

将volatile限定对象类型用作参数类型或返回类型已被弃用。

与任何声明一样，出现在声明之前和声明符内标识符之后的属性都适用于被声明或定义的实体（在此例中为函数）：

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

然而，出现在声明符之后（按上述语法）的属性适用于函数的类型，而非函数本身：

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

返回类型推导

如果函数声明的 decl-specifier-seq 包含关键字 auto ，则可以省略尾随返回类型，编译器将从 非丢弃 return 语句中使用的操作数类型推导得出。如果返回类型未使用 decltype ( auto ) ，则推导遵循 模板实参推导 规则：

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

如果返回类型是 decltype ( auto ) ，则返回类型等同于将返回语句中使用的操作数包裹在 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
}

如果没有返回语句，或者返回语句的操作数是 void 表达式（包括无操作数的返回语句），则声明的返回类型必须是 decltype ( auto ) （此时推导的返回类型为 void ），或者是（可能带有 cv 限定符的） auto （此时推导的返回类型为（具有相同 cv 限定符的） void ）：

auto f() {}              // 返回 void
auto g() { return f(); } // 返回 void
auto* x() {}             // 错误：无法从 void 推导出 auto*

一旦在函数中遇到返回语句，从该语句推导出的返回类型便可用于函数的其余部分，包括其他返回语句：

auto sum(int i)
{
    if (i == 1)
        return i;              // sum的返回类型为int
    else
        return sum(i - 1) + i; // 正确：sum的返回类型已确定
}

如果 return 语句使用 花括号包围的初始化列表 ，则不允许进行推导：

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

虚函数 与 协程 (C++20 起) 不能使用返回类型推导：

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

函数模板 除了 用户定义转换函数 外，均可使用返回类型推导。该推导在实例化时进行，即使返回语句中的表达式不是 依赖名称 。就 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 以确定返回类型，
                                  // 选择第二个模板重载

使用返回类型推导的函数或函数模板的重新声明或特化必须使用相同的返回类型占位符：

auto f(int num) { return num; }
// int f(int num);            // 错误：无占位符返回类型
// decltype(auto) f(int num); // 错误：不同的占位符
template<typename T>
auto g(T t) { return t; }
template auto g(int);     // 正确：返回类型为 int
// template char g(char); // 错误：非主模板 g 的特化

同样地，未使用返回类型推导的函数或函数模板的重新声明或特化不得使用占位符：

int f(int num);
// auto f(int num) { return num; } // 错误：不是对 f 的重声明
template<typename T>
T g(T t) { return t; }
template int g(int);      // 正确：将 T 特化为 int 类型
// template auto g(char); // 错误：不是主模板 g 的特化

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

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

如果任何函数参数使用了 占位符 （ auto 或 概念类型 ），则该函数声明实际上是 简写函数模板 声明：

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

带有说明符 this 的参数声明（语法 ( 2 ) / ( 5 ) ）声明了一个 显式对象参数 。

显式对象参数不能是 函数参数包 ，且它只能出现在以下声明的参数列表的首个参数位置：

• 成员函数 或成员函数模板的声明
• 模板化成员函数的 显式实例化 或 显式特化
• lambda 声明

带有显式对象参数的成员函数具有以下限制：

• 该函数不能是 static 。
• 该函数不能是 virtual 。
• 该函数的声明符不能包含 cv 和 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

• 若异常规范为 非抛出式 ，则所声明函数的类型为
  “派生声明符类型列表 noexcept 函数，其参数为
  参数类型列表 cv  (可选) ref   (可选) 并返回 T ”。

在语法 (2) 中，假设 noptr-declarator 作为独立声明，给定 noptr-declarator 中 qualified-id 或 unqualified-id 的类型为“derived-declarator-type-list T ”（此时 T 必须为 auto ）：

• 若异常规范为 非抛出 ，则声明的函数类型为
  “derived-declarator-type-list noexcept 函数，其参数类型列表为
  parameter-type-list cv  (可选) ref   (可选) ，返回 trailing ”。

• （C++17 前） （C++17 起）否则， 声明的函数类型为
  “derived-declarator-type-list 函数，其参数类型列表为
  parameter-type-list cv  (可选) ref   (可选) ，返回 trailing ”。

attr （若存在）应用于函数类型。

• ref

• 尾随 requires 子句

• 若函数为带有尾随 requires 子句的非模板 friend 函数，其签名包含外围类而非外围命名空间。该签名亦包含尾随 requires 子句。

若函数定义包含 virt-specs ，则必须定义 成员函数 。

若函数定义包含 requires-clause ，则必须定义 模板函数 。

默认函数

如果函数定义采用语法 ( 3 ) ，则该函数被定义为 显式默认 函数。

显式默认化的函数必须是 特殊成员函数 或 比较运算符函数 （自 C++20 起） ，且不得包含 默认实参 。

显式默认的特殊成员函数 F1 允许与原本会被隐式声明的对应特殊成员函数 F2 存在以下差异：

• F1 和 F2 可能具有不同的 ref 和/或 except 限定符。
• 如果 F2 具有类型为 const C & 的非对象参数，则 F1 对应的非对象参数可以是 C& 类型。

如果 F1 的类型与 F2 的类型在前述规则允许范围之外存在差异，则：

• 如果 F1 是赋值运算符，且 F1 的返回类型与 F2 的返回类型不同，或 F1 的非对象参数类型不是引用类型，则程序非良构。
• 否则，如果 F1 在其首次声明时被显式默认化，则将其定义为删除状态。
• 否则，程序非良构。

在首次声明时显式默认化的函数会隐式地成为 inline 函数，并且如果满足条件，会隐式成为 constexpr 函数 。

struct S
{
    S(int a = 0) = default;             // 错误：存在默认参数
    void operator=(const S&) = default; // 错误：返回类型不匹配
    ~S() noexcept(false) = default;     // 正确：异常规范不同
private:
    int i;
    S(S&);          // 正确：私有拷贝构造函数
};
S::S(S&) = default; // 正确：定义拷贝构造函数

显式默认函数和隐式声明函数统称为 默认函数 。它们的实际定义将由编译器隐式提供，详见各自对应的页面说明。

已删除函数

如果函数定义采用语法 ( 4 ) 或 ( 5 ) (C++26 起) ，则该函数被定义为 显式删除 的。

任何对被删除函数的使用都是不合法的（程序将无法编译）。这包括显式调用（使用函数调用运算符）和隐式调用（调用被删除的重载运算符、特殊成员函数、分配函数等），构造指向被删除函数的指针或成员指针，甚至在不属于 潜在求值 的表达式中使用被删除函数。

非纯虚成员函数可以被定义为删除的，即使它被隐式地 odr-used 。删除的函数只能被删除的函数重写，非删除的函数只能被非删除的函数重写。

如果函数被重载， 重载解析 会首先执行，仅当被删除的函数被选中时程序才处于非良构状态：

struct T
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete("new[] is deleted"); // 自 C++26 起
};
T* p = new T;    // 错误：尝试调用已删除的 T::operator new
T* p = new T[5]; // 错误：尝试调用已删除的 T::operator new[]，
                 //        输出诊断信息“new[] is deleted”

被删除的函数定义必须是翻译单元中的首个声明：先前已声明的函数不能重新声明为被删除：

struct T { T(); };
T::T() = delete; // 错误：必须在首次声明时删除

用户提供的函数

如果一个函数是用户声明的，且在其首次声明时未被显式默认化或删除，那么它就是 user-provided 。用户提供的显式默认化函数（即在首次声明后被显式默认化的函数）在其被显式默认化的位置定义；如果此类函数被隐式定义为删除，则程序非良构。在首次声明后将函数声明为默认化，可以在保持稳定二进制接口以适应代码库演进的同时，提供高效的执行和简洁的定义。

// “trivial”的所有特殊成员函数
// 均在各自首次声明时被默认化，
// 它们不属于用户提供
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(); // 首次声明
};
// 未在首次声明时默认化，
// 属于用户提供且在此处定义
nontrivial::nontrivial() = default;

歧义解析

当函数体与以 { 开始的 初始化器 之间存在歧义时 ，或与以 = （自 C++26 起） ，该歧义通过检查 noptr-declarator 的 声明符标识符 类型来解决：

• 如果类型是函数类型，则将歧义标记序列视为函数体。
• 否则，将歧义标记序列视为初始化器。

using T = void(); // 函数类型
using U = int;    // 非函数类型
T a{}; // 定义不执行任何操作的函数
U b{}; // 值初始化 int 对象
T c = delete("hello"); // 将函数定义为已删除
U d = delete("hello"); // 使用 delete 表达式的结果对 int 对象进行拷贝初始化
                       // （格式错误）

__func__

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

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

该变量具有块作用域和静态存储期：

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

#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

函数契约说明符

函数声明和 lambda表达式 可以包含一系列 函数契约说明符  ，每个说明符具有以下语法：

前置条件断言和后置条件断言统称为 函数契约断言  。

函数契约断言是一种与函数关联的 契约断言 。函数契约断言的谓词是其 谓词 上下文转换 为 bool 的结果。

以下函数不能使用函数契约说明符进行声明：

• virtual functions
• deleted functions
• function defaulted on their first declarations

前置条件断言

前置条件断言与进入函数相关联：

int divide(int dividend, int divisor) pre(divisor != 0)
{
    return dividend / divisor;
}
double square_root(double num) pre(num >= 0)
{
    return std::sqrt(num);
}

后置条件断言

后置条件断言与函数正常退出相关联。

如果后置条件断言具有 identifier ，函数契约说明符将引入 identifier 作为关联函数的 结果绑定 名称。结果绑定表示该函数调用返回的对象或引用。结果绑定的类型是其关联函数的返回类型。

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))
        // 通过异常退出永远不会导致契约违例
        throw std::invalid_argument("无效参数");
    return std::sin(num);
}

若后置条件断言包含 标识符 ，且关联函数的返回类型为（可能带有 cv 限定符） void ，则程序非良构：

void f() post(r : r > 0); // 错误：无法为“r”绑定任何值

当非模板函数的声明返回类型包含 占位符类型 时，带有 identifier  的后置条件断言只能出现在函数定义中：

auto g(auto&) post(r : r >= 0); // 正确：“g”是一个模板
auto h() post(r : r >= 0);      // 错误：无法命名返回值
auto k() post(r : r >= 0)       // 正确：“k”是一个定义
{
    return 0;
}

契约一致性

函数或函数模板 func 的 重声明 D 必须不包含 contract-specs ，或者与从 D 可达的任何首次声明 F 具有相同的 contract-specs 。如果 D 和 F 位于不同翻译单元中，则仅当 D 附加到命名模块时才需要诊断。

如果声明 F1 是某个翻译单元中 func 的首个声明，而声明 F2 是另一个翻译单元中 func 的首个声明， F1 和 F2 必须指定相同的 contract-specs ，不要求诊断。

两个 contract-specs 如果包含相同顺序的相同函数契约说明符，则它们是相同的。

函数声明 D1 上的函数契约说明符 C1 与函数声明 D2 上的函数契约说明符 C2 相同，当且仅当满足以下所有条件：

• C1 和 C2 的 predicate 若置于声明 D1 和 D2 的函数定义中（若 D1 和 D2 处于不同翻译单元，则各 predicate 内定义的对应实体行为如同存在具有单一定义的单一实体），应满足 one-definition rule ，但以下重命名情况除外：
  • 所声明函数的形参重命名。
  • 包围所声明函数的模板的模板参数重命名。
  • 结果绑定（若存在）的重命名。
• C1 和 C2 要么均具有 identifier ，要么均不具有。

如果此条件未满足仅因两个lambda表达式的比较所致，且这些表达式包含在 predicate 中，则不需要诊断。

bool b1, b2;
void f() pre (b1) pre([]{ return b2; }());
void f(); // 正确：函数契约说明符被省略
void f() pre (b1) pre([]{ return b2; }()); // 错误：闭包类型不同
void f() pre (b1); // 错误：函数契约说明符不同
int g() post(r : b1);
int g() post(b1); // 错误：缺少结果绑定
namespace N
{
    void h() pre (b1);
    bool b1;
    void h() pre (b1); // 错误：根据单一定义规则
                       //        函数契约说明符存在差异
}