如何实现运行时枚举到类型的映射，简化模板函数调用？

我有两个不相关的类型：Object和Unrelated，它们都实现了同一个基础接口Interface（目的是能存入同一个容器）。

我定义了一个枚举类，用来把这些类型映射为枚举值：

enum class TypeEnum {
    TYPE_OBJECT,
    TYPE_UNRELATED,
};

我还实现了一个读取方法，负责将Interface向下转型为具体的实现类：

template<typename DATA>
const DATA& Read(const Container<Interface>& container, TypeEnum type);

现在我想把下面伪代码里的逻辑自动化，简化成一行代码调用：

switch(type_enum) {
    case TYPE_OBJECT:
        return Read<Object>(container, type_enum);
    case TYPE_UNRELATED:
        return Read<Unrelated>(container, type_enum);
}

注：实际有大约50个枚举值，而且多处需要用到这个逻辑。

我原本尝试用下面的方式实现：

template<typename TypeName>
struct TypePicker;

template<>
struct TypePicker<TYPE_OBJECT> {
    typedef Object underlying_type;
};

template<>
struct TypePicker<TYPE_UNRELATED> {
    typedef Unrelated underlying_type;
};

然后想通过这样的调用实现：

return Read<TypePicker<type_enum>::underlying_type>(container, type_enum);

但问题在于type_enum是运行时才确定的值，这个方案无法生效。请问有没有可行的自动化实现方式？

方案1：编译期生成分发表（C++11及以上） #

借助模板元编程生成函数指针数组，将枚举值与对应的Read实例化函数绑定，运行时直接通过枚举值索引调用，避免手写大量分支。

#include <array>
#include <stdexcept>

// 定义枚举与类型的映射模板
template<TypeEnum E> struct TypeMap;
template<> struct TypeMap<TypeEnum::TYPE_OBJECT> { using type = Object; };
template<> struct TypeMap<TypeEnum::TYPE_UNRELATED> { using type = Unrelated; };
// 其他50个类型的特化依次添加...

// 统一函数签名
using ReadFunc = const Interface&(*)(const Container<Interface>&, TypeEnum);

// 模板生成对应类型的Read包装函数
template<TypeEnum E>
const Interface& ReadWrapper(const Container<Interface>& container, TypeEnum type) {
    return Read<typename TypeMap<E>::type>(container, type);
}

// 编译期生成分发数组（按枚举值顺序排列）
constexpr std::array<ReadFunc, 2> readDispatchTable = {
    ReadWrapper<TypeEnum::TYPE_OBJECT>,
    ReadWrapper<TypeEnum::TYPE_UNRELATED>
    // 补充其他枚举对应的包装函数
};

// 统一调用入口
const Interface& DispatchRead(const Container<Interface>& container, TypeEnum type) {
    auto idx = static_cast<std::size_t>(type);
    if (idx >= readDispatchTable.size()) {
        throw std::invalid_argument("无效的TypeEnum值");
    }
    return readDispatchTable[idx](container, type);
}

调用时只需一行：

return DispatchRead(container, type_enum);

方案2：宏批量生成switch分支（最简兼容方案） #

如果不想用复杂的模板元编程，用宏批量生成switch的case分支，减少重复代码：

#define CASE_TYPE(ENUM_VAL, TYPE) \
    case ENUM_VAL: \
        return Read<TYPE>(container, type_enum);

const Interface& DispatchRead(const Container<Interface>& container, TypeEnum type_enum) {
    switch(type_enum) {
        CASE_TYPE(TypeEnum::TYPE_OBJECT, Object)
        CASE_TYPE(TypeEnum::TYPE_UNRELATED, Unrelated)
        // 其他50个类型的CASE_TYPE调用依次添加...
        default:
            throw std::invalid_argument("无效的TypeEnum值");
    }
}

调用方式与方案1一致。

方案3：访问者模式（适合可修改接口的场景） #

如果允许修改Interface接口，添加接受访问者的方法，可将类型转换逻辑转移到访问者中，彻底消除switch：

// 访问者基类
class InterfaceVisitor {
public:
    virtual void visit(const Object& obj) = 0;
    virtual void visit(const Unrelated& obj) = 0;
    // 其他类型的visit方法依次添加...
};

// 修改Interface接口
class Interface {
public:
    virtual void accept(InterfaceVisitor& visitor) const = 0;
    // 原有接口方法...
};

// 具体类型实现accept方法
class Object : public Interface {
public:
    void accept(InterfaceVisitor& visitor) const override {
        visitor.visit(*this);
    }
};

class Unrelated : public Interface {
public:
    void accept(InterfaceVisitor& visitor) const override {
        visitor.visit(*this);
    }
};

// 实现读取逻辑的访问者
class ReadVisitor : public InterfaceVisitor {
public:
    explicit ReadVisitor(const Container<Interface>& container, TypeEnum type)
        : container_(container), type_(type), result_(nullptr) {}

    void visit(const Object&) override {
        result_ = &Read<Object>(container_, type_);
    }

    void visit(const Unrelated&) override {
        result_ = &Read<Unrelated>(container_, type_);
    }

    const Interface& getResult() const {
        if (!result_) throw std::runtime_error("类型匹配失败");
        return *result_;
    }

private:
    const Container<Interface>& container_;
    TypeEnum type_;
    const Interface* result_;
};

// 封装调用（需根据实际Read逻辑调整，比如从容器中获取对应Interface实例调用accept）
const Interface& DispatchRead(const Container<Interface>& container, TypeEnum type) {
    ReadVisitor visitor(container, type);
    container.get(type).accept(visitor); // 假设container.get(type)返回对应Interface实例
    return visitor.getResult();
}

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