33. 什么是折叠表达式？它在完美转发中有何用途？

折叠表达式（Fold Expression）是C++17引入的一个语法糖。说实话，我第一次看到它的时候，觉得这玩意儿有点花哨。但用久了才发现，它在处理可变参数模板时，简直是神器。

说白了，折叠表达式就是让你能对参数包里的所有参数，用同一个运算符进行折叠操作。比如求和、逻辑与、逗号表达式等等。它让原本需要递归或复杂展开的代码，变成了一行简洁的表达式。

折叠表达式的基本形态

折叠表达式有四种形式，我列个表给你看：

形式	语法	示例（参数包为 args...）	展开结果
一元右折叠	(args op ...)	(args + ...)	arg1 + (arg2 + (arg3 + ...))
一元左折叠	(... op args)	(... + args)	((arg1 + arg2) + arg3) + ...
二元右折叠	(args op ... op init)	(args + ... + 0)	arg1 + (arg2 + (arg3 + ... + 0))
二元左折叠	(init op ... op args)	(0 + ... + args)	(((0 + arg1) + arg2) + arg3) + ...

嗯，这里要注意：一元折叠要求参数包不能为空。二元折叠因为有初始值，所以参数包可以为空。我个人习惯在不确定参数包是否为空时，优先用二元折叠。

一个简单的例子

先来个求和函数，感受一下折叠表达式的威力：

// C++17之前：需要递归或std::apply
template<typename T>
T sum(T t) { return t; }

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

// C++17：一行搞定
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // 一元右折叠
}

你看，从多行递归变成了一行。我在项目中重构过一段老代码，原本有七八个递归展开的模板函数，用折叠表达式全部改成了两三行。编译速度也快了不少——递归展开的模板实例化太多了。

折叠表达式在完美转发中的用途

这才是今天的重点。折叠表达式在完美转发中，最常见的用途就是——批量转发参数。

你想想看，当你写一个工厂函数或者包装函数时，经常需要把一堆参数原封不动地转发给另一个函数。这时候，折叠表达式配合完美转发，就能写出非常优雅的代码。

场景一：批量调用函数

template<typename F, typename... Args>
void invoke_all(F&& f, Args&&... args) {
    // 对每个参数调用f，使用完美转发
    (f(std::forward<Args>(args)), ...);  // 逗号折叠
}

// 使用示例
void print(const std::string& s) {
    std::cout << s << " ";
}

int main() {
    std::string a = "hello", b = "world";
    invoke_all(print, a, std::move(b));
    // 输出：hello world
    // 注意：b已经被移动，不能再使用
}

这里用了逗号折叠表达式。逗号运算符会从左到右依次执行每个表达式，最终返回最后一个表达式的值。但我们这里不关心返回值，只关心副作用——每个参数都被转发调用了。

场景二：构造tuple或容器

template<typename... Args>
auto make_tuple_wrapper(Args&&... args) {
    // 完美转发每个参数到std::make_tuple
    return std::make_tuple(std::forward<Args>(args)...);
    // 注意：这里不是折叠表达式，是包展开
    // 但折叠表达式可以用于类似场景
}

// 更复杂的场景：批量emplace
template<typename Container, typename... Args>
void emplace_all(Container& c, Args&&... args) {
    // 对每个参数，在容器中emplace
    (c.emplace(std::forward<Args>(args)), ...);
}

我曾经在写一个对象池的时候，需要批量构造对象。用折叠表达式配合完美转发，代码简洁得让我自己都惊讶：

template<typename T, typename... Args>
void ObjectPool<T>::construct_multiple(Args&&... args) {
    // 批量构造对象，每个对象都完美转发参数
    (m_objects.emplace_back(std::forward<Args>(args)), ...);
}

避坑指南：折叠表达式中的转发陷阱

这里有个坑，我踩过。你注意看：

// 错误写法
template<typename... Args>
void bad_forward(Args... args) {  // 注意：没有&&
    (f(std::forward<Args>(args)), ...);
}

// 正确写法
template<typename... Args>
void good_forward(Args&&... args) {  // 必须有&&
    (f(std::forward<Args>(args)), ...);
}

为什么？因为只有转发引用（T&&）才能保留值类别。如果你写成 Args... args，那所有参数都是按值传递的，std::forward 就失去了意义。说白了，你转发了个寂寞。

更高级的用法：与lambda结合

有时候，你需要对每个参数执行不同的操作。这时候可以把折叠表达式和lambda结合起来：

template<typename... Args>
void process_args(Args&&... args) {
    // 对每个参数，根据类型做不同处理
    auto handler = [](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_integral_v<T>) {
            std::cout << "整数: " << arg << "\n";
        } else if constexpr (std::is_floating_point_v<T>) {
            std::cout << "浮点数: " << arg << "\n";
        } else {
            std::cout << "其他类型\n";
        }
    };
    
    (handler(std::forward<Args>(args)), ...);
}

这个模式我在写日志库的时候用过。需要把不同类型的参数格式化后拼接成字符串，用折叠表达式加lambda，一行就搞定了所有参数的遍历和转发。

知识体系图

下面这张图总结了折叠表达式在完美转发中的核心逻辑：

总结

折叠表达式在完美转发中的价值，我总结为三点：

1. 代码简洁：把递归展开变成一行表达式，可读性大幅提升
2. 保持语义：配合 std::forward，每个参数的值类别都被完美保留
3. 性能无损：编译期展开，运行时零开销

嗯，最后提醒一句：折叠表达式虽然强大，但别滥用。如果逻辑太复杂，硬塞进一行折叠表达式反而会降低可读性。该拆函数就拆函数，该用循环就用循环。工具是为人服务的，别为了炫技把代码写成了谜语。