如何让C++中双参数包函数正常工作？

1. 函数是否允许包含两个参数包？ #

C++17及后续标准允许函数拥有多个参数包，但存在严格限制：除最后一个参数包外，其余参数包必须具备明确的推导边界。直接声明两个无约束的参数包（如template<typename... Fs, typename... Args> void func(Fs... fs, Args... args)）会导致编译错误，因为编译器无法区分哪些参数属于Fs、哪些属于Args。

2. 编译器如何区分两个参数包的参数？ #

编译器区分多参数包的核心是依赖明确的推导边界，常见实现方式有两种：

• 打包单元法：将每个函数与其对应的参数打包为一个独立单元（比如std::tuple），外层参数包变为多个"函数+参数"组合，编译器可逐个解析单元内的内容。
• 递归展开法：通过函数重载递归处理，每次只解析一个函数及其参数，剩余参数继续传递给下一层调用，利用重载规则划分参数包边界。

适配你场景的可行实现 #

考虑到你的函数/lambda可能与runFuncs不在同一头文件，以下两种实现均符合C++17标准，且具备通用性：

方案一：用std::tuple打包函数与参数 #

将每个回调和其参数打包为tuple，runFuncs接收多个这类tuple，通过辅助函数展开并调用：

#include <tuple>
#include <utility>

// 辅助函数：展开tuple并调用目标函数
template<typename Func, typename... Args, std::size_t... Idx>
void invoke_func(Func&& func, std::tuple<Args...>&& args, std::index_sequence<Idx...>) {
    std::forward<Func>(func)(std::get<Idx>(std::forward<std::tuple<Args...>>(args))...);
}

template<typename Func, typename... Args>
void invoke_func(Func&& func, std::tuple<Args...>&& args) {
    invoke_func(std::forward<Func>(func), std::forward<std::tuple<Args...>>(args),
                std::index_sequence_for<Args...>{});
}

// 主函数：接收多个"函数+参数"的tuple
template<typename... FuncTuples>
void runFuncs(FuncTuples&&... tuples) {
    // C++17折叠表达式展开所有调用
    (invoke_func(std::get<0>(std::forward<FuncTuples>(tuples)),
                 std::get<1>(std::forward<FuncTuples>(tuples))), ...);
}

// 使用示例
#include <iostream>
void foo(int a) { std::cout << "foo: " << a << "\n"; }
auto bar = [](const std::string& s, double d) { std::cout << "bar: " << s << ", " << d << "\n"; };

int main() {
    runFuncs(std::make_tuple(foo, std::make_tuple(42)),
             std::make_tuple(bar, std::make_tuple("hello", 3.14)));
    return 0;
}

方案二：递归展开（无需额外打包） #

通过重载runFuncs实现递归，每次处理一个函数及其参数，剩余参数继续传递：

#include <utility>

// 递归终止条件：无剩余函数待处理
void runFuncs() {}

// 处理单个函数及其参数，递归处理剩余内容
template<typename Func, typename... Args, typename... Rest>
void runFuncs(Func&& func, Args&&... args, Rest&&... rest) {
    std::forward<Func>(func)(std::forward<Args>(args)...);
    runFuncs(std::forward<Rest>(rest)...);
}

// 使用示例
#include <iostream>
void foo(int a) { std::cout << "foo: " << a << "\n"; }
auto bar = [](const std::string& s, double d) { std::cout << "bar: " << s << ", " << d << "\n"; };

int main() {
    runFuncs(foo, 42, bar, "hello", 3.14);
    return 0;
}

该方案调用更简洁，但要求每个函数必须紧跟其所有参数，编译器会自动识别下一个可调用对象作为当前函数参数的结束标记。

关键注意事项 #

• 必须使用std::forward进行完美转发，避免参数拷贝或丢失引用类型信息，确保下游函数正确接收参数。
• lambda表达式只要可调用，无论定义在哪个头文件，调用runFuncs时编译器能识别其类型即可正常使用，无需额外处理。

内容的提问来源于stack exchange，提问作者mgNobody