默认实参

我在这里穿插一个额外的知识点：默认实参。

函数默认实参

假设我现在有一个函数

#include <iostream>
void greeting(const char* who) {
    std::cout << "Hello, " << who << std::endl;
}
int main() {
    greeting("world");
    greeting("Alice");
}

我们可以给它的参数提供一个默认值：

void greeting(const char* who = "world") {
    std::cout << "Hello, " << who << std::endl;
}

这时，我在调用函数时可以略去带有默认值的参数：

int main() {
    greeting(); // 使用默认实参，相当于 greeting("world");
    greeting("Alice"); // 不使用默认实参
}

默认实参就是允许在函数调用表达式中省去末尾若干个实参的语法。它的语法形式是在函数形参后接 = 默认实参值。当调用表达式略去这个实参时，相当于将 默认实参值 当做实参传入了函数。

换句话说，你可以将默认实参理解成提供了若干个新的重载：

void greeting() {
    const char* who = "world";
    std::cout << "Hello, " << who << std::endl;
}
void greeting(const char* who = "world") {
    std::cout << "Hello, " << who << std::endl;
}

函数的默认实参只能在末尾的几个参数提供。如：

void f(int a, int b = 42) { } // OK
void f(int a = 42, int b) { } // 编译错误，默认实参不在结尾
void f(int a = 42, int b = 56) { } // OK，默认实参都在结尾

在调用带有默认实参的函数时，也只能省略末尾的若干个参数：

void f(int a, int b = 42, int c = 56) { }
int main() {
    f(1);      // 相当于 f(1, 42, 56); 省略了 b 和 c
    f(1, 2);   // 相当于 f(1, 2, 56); 省略了 c
//  f(1, , 3); // 错误：没有这种语法
}

默认实参的值可以是表达式，但它有一些限制（如不能（在求值语境下）使用局部变量、this 等）。表达式的求值是在函数调用期间完成的，求得的值会用来初始化函数形参。

#include <iostream>
int x{0};
void f(int a = 2 * (++x)) { // 默认实参为 2 * (++x)，每次调用求值
    std::cout << a << std::endl;
}
int main() {
    f();  // 对默认实参求值
    f(1); // 不对默认实参求值
    f();  // 对默认实参求值
}

如果函数被多次声明，则默认实参只能出现在其中一次声明的位置上。同一形参位置多次出现默认实参是编译错误：

    void f(int a, int b = 42);
//  void f(int a, int b = 42); // 错误：不能多次提供 b 的默认实参
    void f(int a, int b);      // OK

提供默认实参的形参可以省略名字。尽管这看上去没有什么用。

void f(int a, int = 42); // 略去第二个形参的名字，但提供默认实参

成员函数也可以使用默认实参，但非函数调用的运算符重载不能。

默认模板实参

类似地，模板参数也可以提供默认实参。

非类型模板默认实参的写法和函数默认实参非常像：

template<int N = 42, int M = 56>
int add() {
    return N + M;
}
int main() {
    add<>();  // 实例化 add<42, 56>
    add<1>(); // 实例化 add<1, 56>
}

非类型默认模板实参同样也包括如下语法限制：

• 默认模板实参只能在模板形参列表结尾提供；
• 模板实参列表中也只能省略结尾的若干个模板实参；
• 如果函数模板多次被声明，则同一位置的模板默认实参只能出现在其中一个声明中。

但默认模板实参由于其编译期实例化的特点，要求非类型默认模板实参值必须是常量。这是它与函数默认实参最显著的不同点。

类型模板实参拥有类似的语法：

// int 是类型模板形参 U 的默认模板实参
template<typename T, typename U = int>
struct S {
    T mem1;
    U mem2;
};
int main() {
    S<double> a; // 实例化 S<double, int>
}

类型模板默认实参可以使用一个固定的类型，或者任意之前已经被声明的类型（包括前面的模板形参）组成的“表达式”。这个“表达式”并不是真正的表达式，是指由一些类型通过模板、嵌套类或别名声明等一系列语法组成的新类型。比如：

template<typename T>
struct Helper {
    T help() { /* [...] */ }
};
// 依赖于 T 的类型“表达式”作为 U 的默认模板实参
template<typename T, typename U = Helper<T>>
T f() {
    U helper;
    return helper.help();
}
// 例：f<int>(); 实例化 f<int, Helper<int>>

当可以进行模板实参推导时，若某个模板形参没有推导出其值但提供了默认模板实参，则推导成功并采用默认模板实参。这个过程对于类模板、函数模板、非类型模板参数或类型模板参数都适用。

template<typename T, typename U = int>
U cast(T a) {
    return static_cast<U>(a);
}
int main() {
    cast(3.14); // 推导出 T = double，无法从函数实参推导 U
                // 但 U 提供了默认参数 int，从而 U = int
                // 得到返回值类型为 int
}

提供默认模板实参的模板形参可以省略其名字。与函数默认实参不同，这种写法是有一定用处的，我将在比较靠后的篇幅提到。

template<typename T, typename = void> // 省略第二个模板形参名
void f() { }