如何让C++模板函数my_func同时支持可变参数与tuple参数传入？

你的需求完全可以实现，下面提供两种可行方案，结合你提到的结构体场景给出完整示例：

方案1：重载模板函数，直接支持Tuple参数传入 #

给原有的my_func新增一个重载版本，专门处理Tuple类型的参数，借助std::apply将Tuple的元素展开后转发给原可变参数版本：

#include <tuple>
#include <iostream>
#include <string>

struct A {
    static void call_func(int a) {
        std::cout << "A::call_func: " << a << std::endl;
    }
};

struct B {
    static void call_func(int a, double b) {
        std::cout << "B::call_func: " << a << ", " << b << std::endl;
    }
};

struct C {
    static void call_func(int a, double b, const std::string& c) {
        std::cout << "C::call_func: " << a << ", " << b << ", " << c << std::endl;
    }
};

// 原可变参数版本，保持不变
template<typename T, typename... Args>
void my_func(Args&&... args) {
    T::call_func(std::forward<Args>(args)...);
}

// 新增Tuple参数重载版本
template<typename T, typename Tuple>
void my_func(Tuple&& tuple) {
    std::apply([](auto&&... args) {
        my_func<T>(std::forward<decltype(args)>(args)...);
    }, std::forward<Tuple>(tuple));
}

int main() {
    // 原有可变参数调用，正常工作
    my_func<A>(1);
    my_func<B>(2, 3.14);
    my_func<C>(4, 5.67, "hello");

    // 现在可以直接传入Tuple调用
    auto t1 = std::make_tuple(6);
    my_func<A>(t1);
    
    auto t2 = std::make_tuple(7, 8.9);
    my_func<B>(t2);
    
    auto t3 = std::make_tuple(9, 10.11, "world");
    my_func<C>(t3);

    return 0;
}

这个方案的优势是调用方式和原可变参数版本一致，不需要修改原有调用代码，新增的重载会自动匹配Tuple类型的参数。

方案2：不修改原函数，用std::apply直接拆分Tuple调用 #

如果不想修改my_func的定义，可以在调用时直接用std::apply将Tuple拆分为单个参数，转发给原函数：

// 原my_func和结构体定义保持不变

int main() {
    // 原有可变参数调用正常工作
    my_func<A>(1);
    my_func<B>(2, 3.14);
    my_func<C>(4, 5.67, "hello");

    // 使用std::apply拆分Tuple调用
    auto t1 = std::make_tuple(6);
    std::apply([](auto&&... args) {
        my_func<A>(std::forward<decltype(args)>(args)...);
    }, t1);
    
    auto t2 = std::make_tuple(7, 8.9);
    std::apply([](auto&&... args) {
        my_func<B>(std::forward<decltype(args)>(args)...);
    }, t2);
    
    auto t3 = std::make_tuple(9, 10.11, "world");
    std::apply([](auto&&... args) {
        my_func<C>(std::forward<decltype(args)>(args)...);
    }, t3);

    return 0;
}

注意事项 #

• std::apply是C17标准引入的特性，确保你的编译器开启了C17或更高版本的支持（如GCC/Clang添加-std=c++17编译选项）。
• 如果需要兼容C++17之前的版本，可以自行实现一个Tuple展开的工具函数，核心思路是通过递归或索引序列展开Tuple的每个元素。

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