如何将枚举变量传递给针对枚举特化的模板结构体？

模板参数必须是编译期常量，而类成员变量type_哪怕加了const修饰，也是运行时才能确定的值，根本没法直接当模板参数传给TypeTrait。直接传枚举常量能跑，是因为枚举常量属于编译期就能确定的字面量。

下面给几种不用写一堆switch case的实现方式，按需选择：

方案1：用std::variant + std::visit（C++17及以上） #

核心思路就是把运行期的枚举值，转成对应的编译期类型标签，再通过variant的访问机制触发对应特化的逻辑。只需要一次switch用来做映射，后续业务逻辑完全不用碰switch。

示例代码：

#include <variant>
#include <iostream>
#include <stdexcept>

// 定义DataType枚举
enum class DataType { Int, Float, Double };

// TypeTrait模板及特化
template<DataType T>
struct TypeTrait {};

template<>
struct TypeTrait<DataType::Int> {
    static constexpr size_t size = sizeof(int);
};

template<>
struct TypeTrait<DataType::Float> {
    static constexpr size_t size = sizeof(float);
};

template<>
struct TypeTrait<DataType::Double> {
    static constexpr size_t size = sizeof(double);
};

class Test {
private:
    DataType type_;
    // 用变体包装所有编译期枚举标签
    using TypeTagVariant = std::variant<
        std::integral_constant<DataType, DataType::Int>,
        std::integral_constant<DataType, DataType::Float>,
        std::integral_constant<DataType, DataType::Double>
    >;

    // 把运行期type_转成编译期标签变体
    TypeTagVariant get_type_tag() const {
        switch(type_) {
            case DataType::Int: return std::integral_constant<DataType, DataType::Int>{};
            case DataType::Float: return std::integral_constant<DataType, DataType::Float>{};
            case DataType::Double: return std::integral_constant<DataType, DataType::Double>{};
        }
        throw std::invalid_argument("无效的DataType枚举值");
    }

public:
    Test(DataType type) : type_(type) {}

    void Convert() {
        // 访问变体，此时每个分支的tag都是编译期常量
        std::visit([](auto tag) {
            constexpr size_t size = TypeTrait<decltype(tag)::value>::size;
            std::cout << "当前类型大小: " << size << std::endl;
            // 这里直接写对应类型的转换逻辑就行，比如处理int/float/double的转换
        }, get_type_tag());
    }
};

int main() {
    Test t_int(DataType::Int);
    t_int.Convert(); // 输出当前类型大小: 4（32位系统下）
    Test t_double(DataType::Double);
    t_double.Convert(); // 输出当前类型大小: 8
    return 0;
}

方案2：模板元编程生成调度表（C++11及以上） #

用模板在编译期生成一个函数指针数组，把枚举值转成索引直接调用对应逻辑，完全不用写switch。

示例代码：

#include <iostream>
#include <functional>
#include <stdexcept>

enum class DataType { Int, Float, Double };

template<DataType T>
struct TypeTrait {
    static constexpr size_t size = 0; // 占位，特化后覆盖
    static void convert_logic() {}
};

template<>
struct TypeTrait<DataType::Int> {
    static constexpr size_t size = sizeof(int);
    static void convert_logic() {
        std::cout << "处理Int类型，大小: " << size << std::endl;
    }
};

template<>
struct TypeTrait<DataType::Float> {
    static constexpr size_t size = sizeof(float);
    static void convert_logic() {
        std::cout << "处理Float类型，大小: " << size << std::endl;
    }
};

template<>
struct TypeTrait<DataType::Double> {
    static constexpr size_t size = sizeof(double);
    static void convert_logic() {
        std::cout << "处理Double类型，大小: " << size << std::endl;
    }
};

// 模板生成调度表
template<DataType... Ts>
struct DispatchTable {
    static constexpr std::function<void()> table[] = { TypeTrait<Ts>::convert_logic... };
};

// 展开所有枚举值生成调度表
using AllDataTypes = DispatchTable<DataType::Int, DataType::Float, DataType::Double>;

class Test {
private:
    DataType type_;
public:
    Test(DataType type) : type_(type) {}

    void Convert() {
        size_t idx = static_cast<size_t>(type_);
        if (idx >= sizeof(AllDataTypes::table)/sizeof(AllDataTypes::table[0])) {
            throw std::invalid_argument("无效的DataType枚举值");
        }
        // 直接通过索引调用对应函数
        AllDataTypes::table[idx]();
    }
};

int main() {
    Test t_float(DataType::Float);
    t_float.Convert(); // 输出处理Float类型，大小: 4
    return 0;
}

方案3：constexpr if + 编译期枚举序列（C++20及以上） #

利用C++20的constexpr if和递归模板，编译期生成所有匹配分支，运行时直接匹配枚举值，连映射用的switch都不用。

示例代码：

#include <iostream>
#include <stdexcept>

enum class DataType { Int, Float, Double };

template<DataType T>
struct TypeTrait {
    static constexpr size_t size = []() {
        if constexpr (T == DataType::Int) return sizeof(int);
        else if constexpr (T == DataType::Float) return sizeof(float);
        else if constexpr (T == DataType::Double) return sizeof(double);
    }();
};

// 编译期枚举序列模板
template<DataType... Ts>
struct EnumSequence {};

// 包含所有DataType的序列
using AllDataTypes = EnumSequence<DataType::Int, DataType::Float, DataType::Double>;

class Test {
private:
    DataType type_;

    // 递归遍历枚举序列，匹配运行期type_
    template<DataType First, DataType... Rest>
    void dispatch(EnumSequence<First, Rest...>) {
        if (type_ == First) {
            constexpr size_t size = TypeTrait<First>::size;
            std::cout << "当前类型大小: " << size << std::endl;
            // 写对应类型的转换逻辑
        } else {
            dispatch(EnumSequence<Rest...>{});
        }
    }

    // 递归终止条件：没有匹配到枚举值
    void dispatch(EnumSequence<>) {
        throw std::invalid_argument("无效的DataType枚举值");
    }

public:
    Test(DataType type) : type_(type) {}

    void Convert() {
        dispatch(AllDataTypes{});
    }
};

int main() {
    Test t_double(DataType::Double);
    t_double.Convert(); // 输出当前类型大小: 8
    return 0;
}

• C++17及以上优先选方案1，代码简洁好维护，std::visit是标准库的成熟机制。
• 需要兼容C++11就选方案2，完全无switch，编译期生成调度逻辑。
• 能用C++20的话方案3最优雅，连映射用的switch都省了。

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