C++：利用可变参数模板编译时获取函数参数数量并做类型检查

咱们先理清需求：你想在Example类的do_stuff成员函数里，在编译阶段确认传入的参数数量和类型是否和类模板的参数包Types...完全匹配，同时获取参数数量。不过你原来写的函数原型有点问题——const dim_type<N>& elems...这种写法没法把每个参数和tuple里对应位置的类型绑定，单个模板参数N没法对应多个不同的参数类型。

下面是完整的可行实现方案，咱们一步步来：

完整代码实现 #

首先包含必要的头文件：

#include <tuple>
#include <type_traits>
#include <string> // 仅用于示例，可根据需求移除

然后修改Example类，添加编译时检查逻辑：

template<typename... Types> 
class Example { 
public: 
    using types = std::tuple<Types...>; 
    // 提前计算好tuple的大小，方便后续编译时检查
    static constexpr size_t tuple_size = sizeof...(Types);

    template<size_t N> 
    using dim_type = std::tuple_element_t<N, types>; 

    // 核心的do_stuff函数：接收可变参数，编译时做检查
    template<typename... Args>
    inline constexpr void do_stuff(const Args&... args) {
        // 第一关：编译时检查参数数量是否和tuple大小一致
        static_assert(sizeof...(Args) == tuple_size, 
                      "❌ 传入的参数数量必须和Example类模板的参数包大小匹配！");

        // 第二关：编译时逐个检查每个参数的类型是否对应tuple的元素类型
        check_arg_types<0>(args...);

        // 到这里说明参数完全合规，接下来可以写你的业务逻辑
        // 比如递归处理每个参数（示例）
        process_args<0>(args...);
    }

private:
    // 类型检查的递归终止函数
    template<size_t Index>
    constexpr void check_arg_types() {
        static_assert(Index == tuple_size, "✅ 所有参数类型检查通过");
    }

    // 递归检查每个参数的类型
    template<size_t Index, typename FirstArg, typename... RestArgs>
    constexpr void check_arg_types(const FirstArg& first, const RestArgs&... rest) {
        // 检查当前参数的类型是否和tuple第Index个元素的类型一致
        static_assert(std::is_same_v<const FirstArg&, const dim_type<Index>&>,
                      "❌ 某个参数的类型和tuple对应位置的类型不匹配！");
        // 递归检查下一个参数
        check_arg_types<Index + 1>(rest...);
    }

    // 可选：递归处理每个参数的示例函数（根据你的需求修改）
    template<size_t Index>
    constexpr void process_args() {}

    template<size_t Index, typename FirstArg, typename... RestArgs>
    constexpr void process_args(const FirstArg& first, const RestArgs&... rest) {
        // 这里可以对第Index个参数做编译时操作，比如获取值（如果类型支持constexpr）
        // 例如：constexpr auto current_value = first;
        // 继续处理下一个参数
        process_args<Index + 1>(rest...);
    }
};

代码说明 #

1. 参数数量检查：通过sizeof...(Args)获取传入参数的数量，和类模板的tuple_size对比，用static_assert在编译阶段报错，不会等到运行时才发现问题。
2. 参数类型检查：用递归的模板函数check_arg_types，逐个检查每个参数的类型是否和std::tuple对应位置的dim_type<Index>完全一致，同样用static_assert做编译时校验。
3. 业务逻辑扩展：process_args是示例函数，你可以替换成自己需要的编译时参数处理逻辑，比如把参数打包成tuple、计算某个值等。

使用示例 #

int main() {
    // 定义一个包含int、double、string的Example实例
    Example<int, double, std::string> my_example;

    // ✅ 正确调用：参数数量和类型完全匹配
    my_example.do_stuff(42, 3.14, "Hello C++");

    // ❌ 错误调用：参数数量不够，编译时会报错
    // my_example.do_stuff(42, 3.14);

    // ❌ 错误调用：第二个参数类型不匹配（应该是double，传了string），编译时报错
    // my_example.do_stuff(42, "3.14", "Hello");

    return 0;
}

为什么原函数原型不可行？ #

你原来写的template<size_t N> inline constexpr void do_stuff(const dim_type<N>& elems...)有两个问题：

• 可变参数elems...的类型都是dim_type<N>，也就是tuple里第N个元素的类型，没法对应多个不同的类型；
• 单个模板参数N没法同时表示多个参数的位置，所以必须用可变参数模板接收参数，再逐个对应检查。

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