可变参数模板

C++11 引入了 可变参数模板（Variadic Templates），这是该标准新增的最强大和最灵活的特性之一。可变参数模板允许函数和类模板接受任意数量的模板参数，使得编写泛型代码更加简洁和高效。

一、什么是可变参数模板

可变参数模板 是一种特殊的模板，它可以接受 任意数量 的模板参数，包括零个。可变参数模板可以应用于函数模板和类模板，使得编写通用、灵活的代码成为可能。

优势：

泛化参数：支持任意类型、任意数量的参数。
代码简洁：避免了编写大量的重载函数或特化模板。
高效灵活：能够根据需要展开参数，实现复杂的逻辑。

二、可变参数模板的语法

可变参数模板使用 模板参数包（Template Parameter Pack） 和 函数参数包（Function Parameter Pack） 来表示可变数量的模板参数和函数参数。

模板参数包语法：

1

template<typename... Args>

Args... 表示一个模板参数包，可以包含零个或多个模板参数。

函数参数包语法：

1

void function(Args... args)

args... 表示一个函数参数包，对应于模板参数包中的每个类型。

示例：

1
2
3
4


template<typename... Args>
void func(Args... args) {
    // 函数体
}

三、递归展开参数包

在使用可变参数模板时，常常需要 递归地展开参数包，即通过递归调用，将参数包中的每个参数逐一处理。

基本思想：

基例（Base Case）：定义一个非模板函数，作为递归终止条件。
递归（Recursive Case）：定义一个模板函数，每次处理一个参数，然后对剩余参数递归调用。

递归展开示意图：

1
2
3
4
5


print(arg1, arg2, arg3)
    -> print(arg1), print(arg2, arg3)
        -> print(arg2), print(arg3)
            -> print(arg3), print()
                -> 递归终止

四、示例代码解析

下面我们通过一个完整的示例，详细解析可变参数模板的使用方法和递归展开过程。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <iostream>
using namespace std;

// 函数模板，用于向特定对象表白
template <typename T>
void show(T girl) {
    cout << "亲爱的 " << girl << "，我是一只傻傻鸟。\n";
}

// 递归终止条件的非模板函数
void print() {
    cout << "递归终止。\n";
}

// 递归展开参数包的函数模板
template <typename T, typename... Args>
void print(T arg, Args... args) {
    show(arg);         // 处理当前参数
    print(args...);    // 递归处理剩余参数
}

// 包含可变参数的函数模板，可以接受其他常规参数
template <typename... Args>
void func(const string& str, Args... args) {
    cout << str << endl;    // 输出口号
    print(args...);         // 展开并处理参数包
    cout << "表白完成。\n";
}

int main() {
    func("我是绝世帅哥。", "冰冰", 8, "西施", 3);
    return 0;
}

4.1 函数模板 `show`

1
2
3
4


template <typename T>
void show(T girl) {
    cout << "亲爱的 " << girl << "，我是一只傻傻鸟。\n";
}

作用：接受一个参数 girl，输出表白信息。
模板参数：T，用于支持任意类型的参数，例如字符串、整数等。
示例调用：show("冰冰"); 或 show(8);

4.2 非模板函数 `print()`

1
2
3


void print() {
    cout << "递归终止。\n";
}

作用：递归终止条件，当参数包为空时调用。
特点：函数名与递归函数模板相同，但没有参数。

4.3 函数模板 `print`

1
2
3
4
5


template <typename T, typename... Args>
void print(T arg, Args... args) {
    show(arg);         // 处理当前参数
    print(args...);    // 递归处理剩余参数
}

模板参数：
- T：当前处理的参数类型。
- Args...：剩余参数包。
函数参数：
- T arg：当前处理的参数值。
- Args... args：剩余参数包。
实现逻辑：
1. 调用 show(arg)，处理当前参数。
2. 递归调用 print(args...)，处理剩余参数。

4.4 函数模板 `func`

1
2
3
4
5
6


template <typename... Args>
void func(const string& str, Args... args) {
    cout << str << endl;    // 输出口号
    print(args...);         // 展开并处理参数包
    cout << "表白完成。\n";
}

模板参数：Args...，可变参数包。
函数参数：
- const string& str：常规参数，表示口号或前置信息。
- Args... args：可变参数包，将被传递给 print 函数。
实现逻辑：
1. 输出 str。
2. 调用 print(args...)，展开参数包并处理。
3. 输出 “表白完成。”

4.5 `main` 函数

1
2
3
4


int main() {
    func("我是绝世帅哥。", "冰冰", 8, "西施", 3);
    return 0;
}

调用 func：
- "我是绝世帅哥。"：常规参数 str。
- "冰冰", 8, "西施", 3：可变参数包 args...。
执行过程：
1. 输出口号：“我是绝世帅哥。”
2. 展开并处理参数包：
  - 第一次递归：arg = "冰冰", args... = {8, "西施", 3}
  - 第二次递归：arg = 8, args... = {"西施", 3}
  - 第三次递归：arg = "西施", args... = {3}
  - 第四次递归：arg = 3, args... = {}
  - 第五次递归：参数包为空，调用非模板函数 print()
3. 输出 “表白完成。”

运行结果：

1
2
3
4
5
6
7


我是绝世帅哥。
亲爱的 冰冰，我是一只傻傻鸟。
亲爱的 8，我是一只傻傻鸟。
亲爱的 西施，我是一只傻傻鸟。
亲爱的 3，我是一只傻傻鸟。
递归终止。
表白完成。

五、可变参数模板的应用场景

5.1 日志系统

可变参数模板可以用于实现灵活的日志函数，支持任意数量和类型的参数。

1
2
3
4


template<typename... Args>
void log(const Args&... args) {
    (cout << ... << args) << endl; // C++17 的折叠表达式
}

5.2 智能指针的构造

std::make_shared 和 std::make_unique 使用可变参数模板，能够传递任意数量的构造函数参数。

1
2
3
4


template<typename T, typename... Args>
std::shared_ptr<T> make_shared(Args&&... args) {
    return std::shared_ptr<T>(new T(std::forward<Args>(args)...));
}

5.3 库函数的包装

可变参数模板可以用于包装库函数，提供额外的功能，如计时、日志等。

1
2
3
4
5
6
7
8


template<typename Func, typename... Args>
auto measure_time(Func&& func, Args&&... args) {
    auto start = std::chrono::high_resolution_clock::now();
    auto result = func(std::forward<Args>(args)...);
    auto end = std::chrono::high_resolution_clock::now();
    cout << "函数执行时间: " << (end - start).count() << " 纳秒" << endl;
    return result;
}

六、注意事项和最佳实践

6.1 递归终止条件

必须提供递归终止条件，通常是参数包为空时的非模板函数。
避免无限递归，确保递归过程能够正确结束。

6.2 参数传递方式

可以使用 参数传递方式 来优化性能，如按值传递、按引用传递、转发引用等。
如果参数类型未知，使用 转发引用（Forwarding Reference） 更为通用。

1
2
3
4


template<typename T>
void func(T&& arg) {
    // 使用 std::forward<T>(arg) 转发参数
}

6.3 使用折叠表达式（C++17 引入）

在 C++17 中，可以使用 折叠表达式 来简化参数包的展开过程。*

1
2
3
4


template<typename... Args>
void print_all(const Args&... args) {
    (cout << ... << args) << endl;
}

6.4 防止参数包展开顺序问题

在递归展开时，注意参数的处理顺序，确保逻辑正确。
可以使用 初始化列表 或 折叠表达式 控制顺序。

七、总结

可变参数模板是 C++11 引入的强大特性，极大地增强了模板的灵活性和泛型编程能力。通过使用模板参数包和函数参数包，我们可以编写接受任意数量和类型参数的模板函数或类。递归展开参数包是处理可变参数的常用方法，需要注意递归终止条件和参数传递方式。

一、什么是可变参数模板#

二、可变参数模板的语法#

三、递归展开参数包#

四、示例代码解析#

4.1 函数模板 show#

4.2 非模板函数 print()#

4.3 函数模板 print#

4.4 函数模板 func#

4.5 main 函数#

五、可变参数模板的应用场景#

5.1 日志系统#

5.2 智能指针的构造#

5.3 库函数的包装#

六、注意事项和最佳实践#

6.1 递归终止条件#

6.2 参数传递方式#

6.3 使用折叠表达式（C++17 引入）#

6.4 防止参数包展开顺序问题#

七、总结#