Function declaration

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

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

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

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

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

void f() [[noreturn]]; // Error: 此属性对函数本身无影响

返回类型推导

若函数声明的 声明说明符序列 包含关键字 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 ) 必须单独使用）

若存在多个 return 语句，它们必须全部推导为相同类型：

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

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

auto f() {}              // 返回 void
auto g() { return f(); } // 返回 void
auto* x() {}             // Error: 无法从 void 推导 auto*

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

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

若 return 语句使用 花括号初始化列表 ，则不允许推导：

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

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

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

函数模板 （除 用户定义转换函数 外）可使用返回类型推导。推导在实例化时进行，即使 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 以确定返回类型，
                                  // 选择第二个模板重载

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

auto f(int num) { return num; }
// int f(int num);            // Error: 无占位符返回类型
// decltype(auto) f(int num); // Error: 不同的占位符
template<typename T>
auto g(T t<span class="br0

如果任何函数参数使用了 占位符 （ 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 声明

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

• 该函数不能是 静态 的。
• 该函数不能是 虚函数 。
• 函数的声明符不能包含 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 的类型为“派生声明符类型列表 T ”（此时 T 必须为 auto ）：

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

• 否则 (until C++17) 否则 (since C++17) 声明的函数类型为
  “派生声明符类型列表 函数，其参数类型列表为
  parameter-type-list cv  (可选) ref   (可选) 返回 trailing ”。

若存在 attr ，则其应用于函数类型。

• ref

• 尾随 requires 子句

• 若函数为带有尾随 requires 子句的非模板 友元 函数，其签名包含外围类而非外围命名空间。该签名亦包含尾随 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 在其首次声明时显式默认，则它被定义为删除。
• 否则，程序非良构。

在其首次声明时显式默认的函数隐式是 内联 的，并且如果它可以成为 constexpr 函数 ，则隐式是 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 使用 。删除函数只能被删除函数覆盖，非删除函数只能被非删除函数覆盖。

如果函数被重载，首先进行 重载决议 ，仅当选中删除函数时程序才非良构：

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; // 错误：必须在首次声明时删除

用户提供函数

如果函数是用户声明且在其首次声明时未显式默认或删除，则该函数是 用户提供 的。用户提供的显式默认函数（即在首次声明后显式默认）在显式默认处定义；如果此类函数被隐式定义为删除，则程序非良构。在首次声明后将函数声明为默认可以在提供高效执行和简洁定义的同时，为不断演进的代码库提供稳定的二进制接口。

// “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{}; // 值初始化