14. 可变参数模板与完美转发：实现任意参数个数的转发

好，咱们今天聊一个让C++模板真正“活”起来的东西——可变参数模板。说实话，我当年第一次看到这个特性时，第一反应是：“这玩意儿能干嘛？”后来在项目里写一个通用的工厂函数，参数个数死活不确定，才真正体会到它的威力。

你想想看，如果没有可变参数模板，你想写一个能接受任意数量参数的函数，怎么办？重载？那得写到猴年马月。用C风格的va_list？类型安全全没了。嗯，可变参数模板就是来解决这个痛点的。

14.1 什么是可变参数模板

说白了，就是模板参数的数量不固定。你可以传0个、1个、10个参数，模板都能处理。语法上，用typename... Args或者class... Args来声明一个参数包。

template<typename... Args>
void printAll(Args... args) {
    // 这里args就是一个参数包
}

这个Args...叫“模板参数包”，args...叫“函数参数包”。名字不重要，重要的是它们代表了一堆参数。

14.2 如何展开参数包

参数包不能直接使用，你得把它展开。展开的方式有好几种，我挑最常用的说。

14.2.1 递归展开

这是最经典的方式。写一个递归模板，每次处理一个参数，然后递归处理剩下的。

// 递归终止函数（无参数版本）
void printAll() {
    std::cout << "end" << std::endl;
}

// 递归模板函数
template<typename T, typename... Args>
void printAll(T first, Args... rest) {
    std::cout << first << " ";
    printAll(rest...);  // 展开剩余参数
}

// 使用
printAll(1, 2.5, "hello", 'c');
// 输出: 1 2.5 hello c end

我在项目中遇到过一个问题：递归展开如果层数太深，编译时间会暴涨。有一次我写了个递归展开处理100个参数的模板，编译直接卡了5分钟。嗯，后来我改用折叠表达式了。

14.2.2 折叠表达式（C++17）

C++17引入的折叠表达式，让参数包展开变得优雅多了。说白了就是用一个二元运算符把参数包“折叠”起来。

// 一元右折叠 (args op ...)
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // 展开为 arg1 + arg2 + ... + argN
}

// 一元左折叠 (... op args)
template<typename... Args>
auto sumLeft(Args... args) {
    return (... + args);  // 展开为 ((arg1 + arg2) + arg3) + ...
}

// 使用
int result = sum(1, 2, 3, 4, 5);  // 15

14.3 完美转发与可变参数模板的结合

这才是今天的重头戏。你想想看，如果我们要写一个通用的包装函数，把参数原封不动地转发给另一个函数，该怎么办？

嗯，答案就是：可变参数模板 + 完美转发。

template<typename Func, typename... Args>
auto wrapper(Func&& func, Args&&... args) 
    -> decltype(std::forward<Func>(func)(std::forward<Args>(args)...)) 
{
    std::cout << "before call" << std::endl;
    auto result = std::forward<Func>(func)(std::forward<Args>(args)...);
    std::cout << "after call" << std::endl;
    return result;
}

// 使用
void foo(int& a, const std::string& b) {
    a = 42;
    std::cout << b << std::endl;
}

int x = 10;
wrapper(foo, x, std::string("hello"));
// x 被修改为 42

这里的关键是std::forward<Args>(args)...。它把参数包里的每个参数都完美转发出去，保持了左值/右值属性。我曾经在项目里看到有人直接用args...传参，结果右值引用被当成左值传递，导致移动语义失效——这种bug特别难查。

14.4 实战：实现一个通用的工厂函数

我记得有一次，项目里需要根据不同的配置创建不同的对象，参数个数和类型都不固定。用可变参数模板+完美转发，写了一个通用的工厂函数，代码简洁多了。

#include <memory>
#include <utility>

// 通用工厂函数
template<typename T, typename... Args>
std::unique_ptr<T> create(Args&&... args) {
    return std::make_unique<T>(std::forward<Args>(args)...);
}

// 使用示例
struct Widget {
    Widget(int id, const std::string& name) 
        : id_(id), name_(name) {}
    int id_;
    std::string name_;
};

struct Gadget {
    Gadget() = default;
    Gadget(double value) : value_(value) {}
    double value_ = 0.0;
};

auto w = create<Widget>(42, "my widget");
auto g = create<Gadget>(3.14);
auto empty = create<Gadget>();  // 零参数也可以

你看，不管构造函数需要几个参数，create都能完美转发。而且因为是完美转发，右值参数会被移动构造，性能也保住了。

14.5 可变参数模板的常见陷阱

说几个我踩过的坑，你注意避开。

1. 参数包为空时的行为：如果参数包为空，折叠表达式(args + ...)会编译错误，因为没法对空包做折叠。可以用((void)0 + ... + args)或者加一个默认值。
2. 递归展开的编译开销：递归深度太深时，编译器会生成大量模板实例，编译时间和内存都会暴涨。建议用折叠表达式替代。
3. 完美转发与初始化列表：std::forward<Args>(args)...在初始化列表中展开时，求值顺序是未定义的。我曾经因为这个踩过坑，后来改用std::make_tuple或者std::index_sequence来保证顺序。

14.6 知识体系总览

下面这张图总结了可变参数模板与完美转发的核心逻辑，你看一眼就能理清思路。

14.7 总结

可变参数模板和完美转发，这两个特性组合起来，能写出非常灵活且类型安全的通用代码。我个人觉得，这是现代C++里最值得掌握的特性之一。

记住几个要点：

• 参数包用...声明和展开
• 折叠表达式比递归展开更高效、更简洁
• 完美转发必须用std::forward，别偷懒
• 转发引用T&&在模板中不是右值引用，别搞混

嗯，今天就聊到这儿。你可以在自己的项目里试试，比如写一个通用的委托、事件系统或者工厂函数，用可变参数模板+完美转发实现，你会爱上这种写法的。