能否用typeid或其他方式动态调用C++模板函数？

核心问题在于模板是编译期确定的，而std::type_info是运行时类型信息，无法直接作为模板参数使用。要实现"传递类型信息自动调用对应模板"，需要把运行时类型映射到编译期的模板实例，下面是可行的落地方案：

1. 定义类型标识体系 #

首先为所有需要支持的源/目标类型创建编译期唯一标识，同时建立运行时type_info到编译期标识的映射：

#include <typeinfo>
#include <stdexcept>
#include <cstddef>

// 运行时类型ID枚举，覆盖所有需要支持的类型
enum class TypeId {
    Int, Float, Double, Uint32, // 按需添加更多类型
    Unsupported
};

// 编译期类型标签（空结构体，仅用于标识类型）
struct TagInt {};
struct TagFloat {};
struct TagDouble {};
struct TagUint32 {};

// 类型到标签的编译期映射
template<typename T> struct TypeTag;
template<> struct TypeTag<int> { using type = TagInt; };
template<> struct TypeTag<float> { using type = TagFloat; };
template<> struct TypeTag<double> { using type = TagDouble; };
template<> struct TypeTag<uint32_t> { using type = TagUint32; };

// 运行时type_info转TypeId
TypeId get_type_id(const std::type_info& ti) {
    if (ti == typeid(int)) return TypeId::Int;
    if (ti == typeid(float)) return TypeId::Float;
    if (ti == typeid(double)) return TypeId::Double;
    if (ti == typeid(uint32_t)) return TypeId::Uint32;
    // 新增类型时在这里添加入口
    return TypeId::Unsupported;
}

2. 核心转换模板 #

编写通用的转换模板，实现默认转换逻辑；需要特殊处理的类型对可以单独特化：

// 通用转换模板：实现默认类型转换逻辑
template<typename Src, typename Dest>
void convert_buffer_impl(const Src* src_buf, size_t elem_count, Dest* dest_buf) {
    // 基础转换逻辑，比如类型强转、字节序调整等
    for (size_t i = 0; i < elem_count; ++i) {
        dest_buf[i] = static_cast<Dest>(src_buf[i]);
    }
}

// 特化示例：int转uint32_t的特殊处理（比如处理负数）
template<>
void convert_buffer_impl<int, uint32_t>(const int* src_buf, size_t elem_count, uint32_t* dest_buf) {
    for (size_t i = 0; i < elem_count; ++i) {
        dest_buf[i] = src_buf[i] < 0 ? 0 : static_cast<uint32_t>(src_buf[i]);
    }
}

3. 双层分发器实现动态调用 #

通过两层switch分发，先匹配源类型，再匹配目标类型，最终调用对应的模板实例：

// 第二层分发：确定源类型后，分发到目标类型的转换模板
template<typename Src>
void dispatch_dest(const Src* src_buf, size_t elem_count, TypeId dest_id, void* dest_buf) {
    switch (dest_id) {
        case TypeId::Int:
            convert_buffer_impl(src_buf, elem_count, static_cast<int*>(dest_buf));
            break;
        case TypeId::Float:
            convert_buffer_impl(src_buf, elem_count, static_cast<float*>(dest_buf));
            break;
        case TypeId::Double:
            convert_buffer_impl(src_buf, elem_count, static_cast<double*>(dest_buf));
            break;
        case TypeId::Uint32:
            convert_buffer_impl(src_buf, elem_count, static_cast<uint32_t*>(dest_buf));
            break;
        default:
            throw std::invalid_argument("Unsupported destination type");
    }
}

// 顶层分发：根据源TypeId分发到对应源类型的处理分支
void convert_buffer(const std::type_info& src_type, const void* src_buf, size_t elem_count,
                    const std::type_info& dest_type, void* dest_buf) {
    TypeId src_id = get_type_id(src_type);
    TypeId dest_id = get_type_id(dest_type);

    if (src_id == TypeId::Unsupported || dest_id == TypeId::Unsupported) {
        throw std::invalid_argument("Unsupported type pair");
    }

    switch (src_id) {
        case TypeId::Int:
            dispatch_dest(static_cast<const int*>(src_buf), elem_count, dest_id, dest_buf);
            break;
        case TypeId::Float:
            dispatch_dest(static_cast<const float*>(src_buf), elem_count, dest_id, dest_buf);
            break;
        case TypeId::Double:
            dispatch_dest(static_cast<const double*>(src_buf), elem_count, dest_id, dest_buf);
            break;
        case TypeId::Uint32:
            dispatch_dest(static_cast<const uint32_t*>(src_buf), elem_count, dest_id, dest_buf);
            break;
        default:
            throw std::invalid_argument("Unsupported source type");
    }
}

4. 使用方式 #

直接传入源/目标类型的type_info和缓冲区即可：

#include <vector>

int main() {
    std::vector<int> src = {1, 2, 3, -4};
    std::vector<uint32_t> dest(src.size());

    convert_buffer(typeid(int), src.data(), src.size(),
                   typeid(uint32_t), dest.data());

    // dest现在是[1,2,3,0]，符合特化的转换逻辑
    return 0;
}

优化与注意事项 #

• 减少重复代码：可以用宏自动生成类型标签、TypeTag特化和switch分支，比如：

  #define REGISTER_TYPE(T, TAG_NAME, TYPE_ID) \
  struct TAG_NAME {}; \
  template<> struct TypeTag<T> { using type = TAG_NAME; }; \
  case TypeId::TYPE_ID: \
      dispatch_dest(static_cast<const T*>(src_buf), elem_count, dest_id, dest_buf); \
      break;
  

  新增类型时只需调用宏，避免手动重复编写。
• 跨动态库问题：不同动态库中同一类型的type_info可能不相等，此时需替换为自定义的类型ID（比如提前为每个类型分配唯一整数），不要依赖std::type_info的比较。
• 缓冲区安全：调用前需确保目标缓冲区大小足够容纳转换后的元素，或者在convert_buffer_impl中添加大小校验。

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