如何在C++可变参数模板中为每个类型绑定非类型参数？

当然可以实现！你的需求是把多组「枚举类型+位掩码」的组合作为模板参数传入，自动生成泛化的解包逻辑对吧？我们可以通过封装类型-非类型参数对的方式来解决这个问题，下面一步步拆解实现：

第一步：封装类型-非类型参数对 #

首先我们需要一个辅助模板结构体，把每一对「枚举类型 + 位掩码」打包成一个独立的类型，这样就能作为模板参数传递了：

#include <cstdint>
#include <tuple>

template<typename EnumT, uint8_t Mask>
struct EnumMaskPair {
    // 暴露枚举类型，方便后续复用
    using EnumType = EnumT;
    // 暴露位掩码常量
    static constexpr uint8_t bitmask = Mask;
    
    // 可选：把解包逻辑封装到结构体内部，让代码更模块化
    static constexpr EnumType unpack(uint8_t value) {
        return static_cast<EnumType>(value & Mask);
    }
};

第二步：实现泛化的解包函数 #

接下来我们用可变参数模板接受多个EnumMaskPair实例，生成对应的解包逻辑。这里先实现返回std::tuple的版本，它能自动适配任意数量的参数对：

定义返回类型（兼容C++11及以上） #

我们可以用模板元编程提前推导返回的tuple类型：

// 递归构建返回的tuple类型
template<typename... Pairs>
struct UnpackedTupleType;

// 递归分支：处理第一个参数对，拼接剩余参数对的类型
template<typename EnumT, uint8_t Mask, typename... Rest>
struct UnpackedTupleType<EnumMaskPair<EnumT, Mask>, Rest...> {
    using type = std::tuple<EnumT, typename UnpackedTupleType<Rest...>::type>;
};

// 终止分支：空参数时返回空tuple
template<>
struct UnpackedTupleType<> {
    using type = std::tuple<>;
};

// 用别名简化类型书写
template<typename... Pairs>
using UnpackedTuple = typename UnpackedTupleType<Pairs...>::type;

实现解包函数 #

利用C17的折叠表达式可以写出非常简洁的代码，如果需要兼容C11，也可以用递归展开的方式：

// C++17及以上版本（折叠表达式更简洁）
template<typename... Pairs>
UnpackedTuple<Pairs...> unpack_from_single_byte(uint8_t value) {
    return std::make_tuple(Pairs::unpack(value)...);
}

// 兼容C++11的递归版本
inline std::tuple<> unpack_from_single_byte(uint8_t) {
    return {};
}

template<typename FirstPair, typename... RestPairs>
auto unpack_from_single_byte(uint8_t value) -> decltype(std::tuple_cat(
    std::make_tuple(FirstPair::unpack(value)),
    unpack_from_single_byte<RestPairs...>(value)
)) {
    return std::tuple_cat(
        std::make_tuple(FirstPair::unpack(value)),
        unpack_from_single_byte<RestPairs...>(value)
    );
}

第三步：调用示例 #

现在你可以像这样调用泛化的解包函数了：

// 定义你的枚举类型
enum class Type1 : uint8_t { first, second };
enum class Type2 : uint8_t { first, second, third, forth };
enum class Type3 : uint8_t { first, second };

int main() {
    uint8_t input_byte = 0x3F; // 示例输入
    
    // 传入多组EnumMaskPair实例作为模板参数
    auto result = unpack_from_single_byte<
        EnumMaskPair<Type1, 0x03>,
        EnumMaskPair<Type2, 0x3C>,
        EnumMaskPair<Type3, 0xC0>
    >(input_byte);
    
    // 用结构化绑定（C++17及以上）快速获取每个枚举值
    auto [var1, var2, var3] = result;
    
    // 或者用std::get访问tuple中的元素
    Type1 v1 = std::get<0>(result);
    Type2 v2 = std::get<1>(result);
    Type3 v3 = std::get<2>(result);
}

额外：返回自定义结构体 #

如果你想要返回像你原来代码中的自定义结构体（而不是tuple），可以用std::apply把tuple转换为结构体：

// 定义你的自定义结构体
struct Unpacked {
    Type1 var1;
    Type2 var2;
    Type3 var3;
};

int main() {
    uint8_t input_byte = 0x3F;
    auto tuple_result = unpack_from_single_byte<
        EnumMaskPair<Type1, 0x03>,
        EnumMaskPair<Type2, 0x3C>,
        EnumMaskPair<Type3, 0xC0>
    >(input_byte);
    
    // 用std::apply将tuple转换为自定义结构体
    Unpacked unpacked = std::apply(
        [](auto... args) { return Unpacked{args...}; },
        tuple_result
    );
}

或者你可以封装一个更直接的函数，直接返回自定义结构体：

template<typename StructT, typename... Pairs>
StructT unpack_to_struct(uint8_t value) {
    auto tuple_result = unpack_from_single_byte<Pairs...>(value);
    return std::apply([](auto... args) { return StructT{args...}; }, tuple_result);
}

// 调用方式
Unpacked result = unpack_to_struct<Unpacked,
    EnumMaskPair<Type1, 0x03>,
    EnumMaskPair<Type2, 0x3C>,
    EnumMaskPair<Type3, 0xC0>
>(input_byte);

为什么你原来的写法不行？ #

你原来尝试的template<template<typename EnumType, uint8_t Bitmask> typename... EnumsAndBitmasks>是模板模板参数的可变参数，它接受的是模板本身（比如EnumMaskPair），而不是模板实例化后的具体类型（比如EnumMaskPair<Type1, 0x03>）。所以我们需要先把每一对参数封装成具体的类型实例，再作为可变参数传递。

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