能否创建std::type_info数组？C++模板调用冗余消除方案咨询

首先明确：没法通过std::type_info数组动态传递模板类型来调用getValue。模板参数是编译期必须确定的常量，而std::type_info是运行时才生成的类型信息，编译器没办法在运行时根据它推导出模板参数并生成对应的函数实例，二者本质上是编译期和运行时的鸿沟，没法直接桥接。

下面给你几个实用的替代方案，彻底消除switch分支：

方案1：预注册类型处理映射表 #

把每个整数值对应的类型逻辑（包括调用getValue<T>）封装成可调用对象，提前注册到哈希表中，运行时直接按ID查表调用。

示例代码：

#include <unordered_map>
#include <functional>
#include <iostream>

// 假设你的getValue模板函数
template<typename T>
T getValue(void* mem_ptr) {
    return *reinterpret_cast<T*>(mem_ptr);
}

// 定义处理函数的签名，可根据业务需求调整
using TypeHandler = std::function<void(void*)>;
std::unordered_map<int, TypeHandler> type_handler_map;

// 模板注册函数，新增类型时只需要调用这个
template<typename T>
void register_type(int type_id) {
    type_handler_map[type_id] = [](void* mem_ptr) {
        T value = getValue<T>(mem_ptr);
        // 这里替换成你的实际业务逻辑，比如存储、打印、计算等
        std::cout << "类型ID " << type_id << " 对应的值：" << value << std::endl;
    };
}

// 初始化所有支持的类型
void init_type_handlers() {
    register_type<int>(1);
    register_type<float>(2);
    register_type<double>(3);
    register_type<char>(4);
    // 新增类型直接加一行register_type就行
}

int main() {
    init_type_handlers();
    
    // 模拟内存映射的指针和类型ID
    int int_val = 123;
    float float_val = 45.6f;
    void* int_ptr = &int_val;
    void* float_ptr = &float_val;
    
    // 直接用ID调用对应逻辑，完全没switch
    type_handler_map[1](int_ptr);
    type_handler_map[2](float_ptr);
    
    return 0;
}

这个方案的优势是维护成本极低——新增类型只需要加一行注册代码，不用修改任何分支逻辑。

方案2：用std::variant统一存储多类型值 #

如果你的业务需要统一管理不同类型的结果，可以用std::variant作为容器，把类型ID映射到variant的对应类型。

示例代码：

#include <variant>
#include <unordered_map>
#include <iostream>

template<typename T>
T getValue(void* mem_ptr) {
    return *reinterpret_cast<T*>(mem_ptr);
}

// 定义支持的所有类型的variant
using ValueVariant = std::variant<int, float, double, char>;
std::unordered_map<int, std::function<ValueVariant(void*)>> type_to_variant;

template<typename T>
void register_variant_type(int type_id) {
    type_to_variant[type_id] = [](void* mem_ptr) -> ValueVariant {
        return getValue<T>(mem_ptr);
    };
}

int main() {
    register_variant_type<int>(1);
    register_variant_type<float>(2);
    
    float val = 78.9f;
    void* ptr = &val;
    
    // 根据ID获取variant包装的值
    ValueVariant result = type_to_variant[2](ptr);
    // 用std::visit处理variant中的具体值
    std::visit([](auto&& arg) {
        std::cout << "获取到的值：" << arg << std::endl;
    }, result);
    
    return 0;
}

这种方案适合需要把不同类型值统一存储、传递的场景，后续处理逻辑可以通过std::visit统一分发。

方案3：编译期自动生成映射表（进阶） #

如果类型和ID的对应关系是编译期固定的，可以用模板元编程自动生成映射表，连手动注册都省了。

示例代码片段：

#include <tuple>
#include <utility>
#include <unordered_map>
#include <iostream>

template<typename T>
T getValue(void* mem_ptr) {
    return *reinterpret_cast<T*>(mem_ptr);
}

using TypeHandler = std::function<void(void*)>;

// 编译期遍历tuple生成映射表
template<typename... Ts>
struct CompileTimeTypeMap {
    static std::unordered_map<int, TypeHandler> create(int... type_ids) {
        std::unordered_map<int, TypeHandler> map;
        // 折叠表达式编译期生成每个类型的处理函数
        (map.emplace(type_ids, [](void* ptr) {
            auto val = getValue<Ts>(ptr);
            std::cout << "值：" << val << std::endl;
        }), ...);
        return map;
    }
};

int main() {
    // 定义支持的类型和对应的ID
    using SupportedTypes = std::tuple<int, float, double, char>;
    auto handlers = CompileTimeTypeMap<
        std::tuple_element_t<0, SupportedTypes>,
        std::tuple_element_t<1, SupportedTypes>,
        std::tuple_element_t<2, SupportedTypes>,
        std::tuple_element_t<3, SupportedTypes>
    >::create(1, 2, 3, 4);
    
    int val = 100;
    handlers[1](&val);
    return 0;
}

这个方案适合类型固定且数量较多的场景，编译期自动完成所有映射，完全不用手动写注册逻辑。

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