C++ 可变参数模板的高级展开技巧：递归与折叠表达式 (C++17)

哈喽，各位好！今天咱们来聊聊C++中可变参数模板的那些高级玩意儿，特别是递归展开和折叠表达式。这俩兄弟，一个古老而强大，一个新潮又简洁，都是玩转模板元编程的利器。准备好了吗？咱们这就开始！

第一部分：可变参数模板基础回顾

首先，为了照顾一下可能对可变参数模板还不太熟悉的朋友，咱们先简单回顾一下基础知识。

可变参数模板，顾名思义，就是可以接受数量不定的参数的模板。它通过 ... (省略号) 这个神奇的符号来实现。通常，我们会用两种方式来声明可变参数模板：

模板参数包 (Template Parameter Pack): 用于接受类型参数。
```
template <typename... Args>
void my_function(Args... args) {
    // ...
}
```
在这里，Args 就是一个模板参数包，它可以包含零个或多个类型。
函数参数包 (Function Parameter Pack): 用于接受函数参数。
```
template <typename... Args>
void my_function(Args... args) {
    // ...
}
```
在这里，args 就是一个函数参数包，它可以包含零个或多个参数。

如何使用参数包？

使用参数包的关键在于如何将其展开。展开参数包就是把参数包里面的每一个参数都拿出来，分别进行处理。在C++11和C++14中，主要依赖于递归展开。而在C++17中，我们有了更方便的折叠表达式。

第二部分：递归展开：古老而强大的方法

递归展开是C++11/14时代处理参数包的主要手段。它的核心思想是：定义一个递归函数，每次处理参数包中的一个参数，直到参数包为空。

一个简单的例子：打印参数包中的所有参数

#include <iostream>

// 递归终止条件：当参数包为空时
void print() {
    std::cout << "End of argumentsn";
}

// 递归函数：每次处理一个参数
template <typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";
    print(rest...); // 递归调用，处理剩余的参数
}

int main() {
    print(1, 2.5, "hello", 'c'); // 调用 print 函数
    return 0;
}

代码解释:

void print()：这是递归的终止条件。当参数包为空时，调用这个函数，输出 "End of arguments"。
template <typename T, typename... Args> void print(T first, Args... rest)：这是递归函数。
- T first：提取参数包中的第一个参数，类型为T。
- Args... rest：剩余的参数组成一个新的参数包 rest。
- std::cout << first << " ";：打印第一个参数。
- print(rest...)：递归调用 print 函数，处理剩余的参数。

递归展开的优点：

通用性强： 几乎可以处理任何复杂的参数包操作。
易于理解： 递归思想比较直观。

递归展开的缺点：

代码冗长： 需要定义额外的递归终止函数。
编译时间可能较长： 递归展开可能导致大量的模板实例化。
容易出错： 递归终止条件如果没写对，就可能导致无限递归，编译错误。

一个更复杂的例子：计算参数包中所有数字的和

#include <iostream>

// 递归终止条件：参数包为空，返回 0
template <typename T>
T sum(T value){
    return value;
}

template <typename T, typename... Args>
T sum(T first, Args... rest) {
    return first + sum(rest...);
}

int main() {
    std::cout << sum(1, 2, 3, 4, 5) << std::endl; // 输出 15
    return 0;
}

第三部分：C++17 折叠表达式：简洁而高效的方法

C++17 引入了折叠表达式，这是一种更简洁、更高效的方式来处理参数包。折叠表达式使用 ... 运算符直接对参数包进行操作，无需显式递归。

折叠表达式的语法

折叠表达式有四种形式：

一元右折叠 (Unary Right Fold): (pack op ...) 例如: (args + ...)
一元左折叠 (Unary Left Fold): (... op pack) 例如: (... + args)
二元右折叠 (Binary Right Fold): (pack op ... op init) 例如: (args + ... + 0)
二元左折叠 (Binary Left Fold): (init op ... op pack) 例如: (0 + ... + args)

其中：

pack 是参数包。
op 是运算符 (例如 +, -, *, /, &&, ||, , 等)。
init 是初始值。

用折叠表达式重写之前的例子

1. 打印参数包中的所有参数

#include <iostream>

template <typename... Args>
void print(Args... args) {
    (std::cout << ... << args << " ");
    std::cout << std::endl;
}

int main() {
    print(1, 2.5, "hello", 'c'); // 输出 1 2.5 hello c
    return 0;
}

代码解释:

(std::cout << ... << args << " ")：这是一个一元左折叠表达式。它等价于 (((std::cout << args1 << " ") << args2 << " ") << ...)，也就是把每个参数都输出到 std::cout。

2. 计算参数包中所有数字的和

#include <iostream>

template <typename... Args>
auto sum(Args... args) {
    return (args + ... + 0); // 二元右折叠
}

int main() {
    std::cout << sum(1, 2, 3, 4, 5) << std::endl; // 输出 15
    return 0;
}

代码解释:

(args + ... + 0)：这是一个二元右折叠表达式。它等价于 (args1 + (args2 + (args3 + ... + 0)))，也就是从最后一个参数开始，依次向前加。

折叠表达式的优点：

简洁： 代码量大大减少。
高效： 编译器可以更好地优化折叠表达式。
可读性好： 表达式更易于理解。

折叠表达式的缺点：

适用范围有限： 只能用于某些特定的操作 (例如算术运算、逻辑运算等)。对于复杂的参数包操作，可能仍然需要递归展开。
需要 C++17 支持： 较旧的编译器可能不支持折叠表达式。

折叠表达式的更多用法

1. 逻辑与 (AND)

#include <iostream>

template <typename... Args>
bool all_true(Args... args) {
    return (true && ... && args);
}

int main() {
    std::cout << all_true(true, true, true) << std::endl;    // 输出 1
    std::cout << all_true(true, false, true) << std::endl;   // 输出 0
    return 0;
}

2. 逻辑或 (OR)

#include <iostream>

template <typename... Args>
bool any_true(Args... args) {
    return (false || ... || args);
}

int main() {
    std::cout << any_true(false, false, true) << std::endl;   // 输出 1
    std::cout << any_true(false, false, false) << std::endl;  // 输出 0
    return 0;
}

3. 逗号运算符 (Comma Operator)

#include <iostream>

template <typename... Args>
void do_something(Args... args) {
    (void(args), ...); // 利用逗号运算符依次执行每个表达式
}

void func1() { std::cout << "func1 calledn"; }
void func2() { std::cout << "func2 calledn"; }
void func3() { std::cout << "func3 calledn"; }

int main() {
    do_something(func1(), func2(), func3());
    return 0;
}

代码解释:

(void(args), ...)：这是一个一元右折叠表达式，利用逗号运算符依次执行每个表达式。void(args) 将每个参数转换为 void 类型，避免编译器警告。
这个例子展示了如何利用折叠表达式依次调用多个函数。

第四部分：递归展开与折叠表达式的选择

那么，在实际开发中，我们应该选择递归展开还是折叠表达式呢？这取决于具体的应用场景。

特性	递归展开	折叠表达式
适用范围	广泛，可以处理复杂的参数包操作	某些特定操作 (算术、逻辑、逗号等)
代码量	较多	较少
效率	可能较低，可能导致大量的模板实例化	较高，编译器可以更好地优化
可读性	一般	较好
C++ 版本要求	C++11/14 即可	C++17

总结：

如果你的代码需要兼容 C++11/14，或者需要处理非常复杂的参数包操作，那么递归展开是你的不二之选。
如果你的代码只需要支持 C++17，并且参数包操作比较简单 (例如算术运算、逻辑运算等)，那么折叠表达式是一个更简洁、更高效的选择。

第五部分：高级技巧：SFINAE 与可变参数模板

SFINAE (Substitution Failure Is Not An Error) 是一种模板编程技巧，它允许编译器在模板参数推导失败时，不产生编译错误，而是选择其他可用的模板。SFINAE 可以与可变参数模板结合使用，实现更灵活的模板元编程。

一个例子：判断参数包中是否包含某种类型

#include <iostream>
#include <type_traits>

template <typename T, typename... Args>
struct contains {
private:
    template <typename U>
    static std::true_type test(decltype(std::declval<U&>())); // 如果 U 可以转换为 T，则匹配

    template <typename U>
    static std::false_type test(...); // 如果 U 不能转换为 T，则匹配

public:
    static constexpr bool value = decltype(test<T>(0))::value;
};

template <typename T, typename U, typename... Args>
struct contains<T, U, Args...> {
private:
    template <typename V>
    static std::true_type test(decltype(std::declval<V&>())); // 如果 V 可以转换为 T，则匹配

    template <typename V>
    static std::false_type test(...); // 如果 V 不能转换为 T，则匹配

public:
    static constexpr bool value = contains<T, Args...>::value || decltype(test<U>(0))::value;
};

int main() {
    std::cout << contains<int, double, char, int>::value << std::endl;   // 输出 1
    std::cout << contains<int, double, char, float>::value << std::endl;  // 输出 0
    return 0;
}

代码解释:

contains<T, Args...>：这是一个模板类，用于判断类型 T 是否包含在类型列表 Args... 中。
test<U>：这是一个静态成员函数，利用 SFINAE 来判断类型 U 是否可以转换为 T。
- 如果 U 可以转换为 T，则匹配 std::true_type test(decltype(std::declval<U&>()))，返回 std::true_type。
- 如果 U 不能转换为 T，则匹配 std::false_type test(...)，返回 std::false_type。
contains<T, U, Args...>：这是 contains 的特化版本，用于递归判断剩余的类型列表 Args... 中是否包含 T。
contains<T, Args...>::value || decltype(test<U>(0))::value：利用递归和逻辑或运算符，判断类型 T 是否包含在类型列表 Args... 中。

第六部分：实际应用场景

可变参数模板在实际开发中有很多应用场景，例如：

实现通用的工厂函数： 可以根据不同的参数类型创建不同的对象。
实现通用的日志系统： 可以接受任意数量的参数，并将它们格式化输出到日志文件中。
实现通用的序列化/反序列化函数： 可以将任意数量的对象序列化到文件中，或者从文件中反序列化出任意数量的对象。
实现各种容器适配器： 例如 std::tuple、std::variant 等。

第七部分：总结

今天咱们一起学习了C++可变参数模板的高级展开技巧，包括递归展开和折叠表达式。递归展开是一种古老而强大的方法，可以处理任何复杂的参数包操作。折叠表达式是一种简洁而高效的方法，适用于某些特定的操作。在实际开发中，我们应该根据具体的应用场景选择合适的展开方式。同时，SFINAE 可以与可变参数模板结合使用，实现更灵活的模板元编程。

希望今天的讲解对大家有所帮助！祝大家编程愉快！

发表回复 取消回复

发表回复取消回复