如何在C++中根据ID动态选择调用类的模板成员函数？

针对你遇到的消息ID对应不同结构体，需要调用NamePrinter类中任意模板成员函数的问题，可以通过编译期类型映射+函数表分发的方式实现通用逻辑，避免硬编码。

步骤1：定义消息结构体与ID-类型映射 #

首先明确消息类型和对应的ID，用模板特化实现编译期的ID到类型的映射：

#include <iostream>
#include <array>
#include <functional>
#include <cstddef>
#include <cstdint>

// 消息结构体定义
struct MsgA { /* 实际字段 */ };
struct MsgB { /* 实际字段 */ };
struct MsgC { /* 实际字段 */ };

// 编译期ID到消息类型的映射模板
template<int ID>
struct MsgTypeFromID;

template<> struct MsgTypeFromID<1> { using type = MsgA; };
template<> struct MsgTypeFromID<2> { using type = MsgB; };
template<> struct MsgTypeFromID<3> { using type = MsgC; };

// 辅助别名简化类型获取
template<int ID>
using MsgTypeFromID_t = typename MsgTypeFromID<ID>::type;

步骤2：实现NamePrinter类 #

保持原有的模板成员函数不变：

class NamePrinter {
public:
    template<typename T>
    void onMsgPrintName(T msg) {
        std::cout << "Print name: " << typeid(T).name() << "\n";
    }

    template<typename T>
    void onMsgPrintSomethingElse(T msg) {
        std::cout << "Print extra info: " << typeid(T).name() << "\n";
    }
};

步骤3：通用分发逻辑实现 #

核心是通过模板生成对应ID的处理函数，再组成编译期函数表，实现根据ID调用任意指定的模板成员函数：

// 辅助函数：针对指定ID和成员函数，生成具体的消息处理逻辑
template<int ID, template<typename> typename MemFunc>
void handleMessage(NamePrinter& printer) {
    using MsgT = MsgTypeFromID_t<ID>;
    // 这里可以替换为从字节流解析MsgT的逻辑，示例中用默认构造
    MsgT msg;
    std::invoke(MemFunc{}, printer, msg);
}

// 通用的ID分发函数：接受任意模板成员函数作为参数
template<template<typename> typename MemFunc>
void intToFunc(NamePrinter& printer, int msgId) {
    // 编译期生成函数表，索引对应消息ID
    static constexpr std::array<void(*)(NamePrinter&), 4> funcTable = {
        nullptr,          // ID=0 无效
        handleMessage<1, MemFunc>,
        handleMessage<2, MemFunc>,
        handleMessage<3, MemFunc>
    };

    if (msgId >= 1 && msgId <= 3 && funcTable[msgId]) {
        funcTable[msgId](printer);
    } else {
        std::cerr << "Invalid message ID: " << msgId << "\n";
    }
}

步骤4：调用示例 #

在主函数中可以直接调用通用分发函数，指定要调用的NamePrinter模板成员函数：

int main() {
    NamePrinter printer;

    // 调用onMsgPrintName处理ID=1的消息
    intToFunc<&NamePrinter::onMsgPrintName>(printer, 1);
    // 调用onMsgPrintSomethingElse处理ID=2的消息
    intToFunc<&NamePrinter::onMsgPrintSomethingElse>(printer, 2);
    // 无效ID测试
    intToFunc<&NamePrinter::onMsgPrintName>(printer, 4);

    return 0;
}

适配字节流解析场景 #

如果需要从字节流解析消息，只需修改handleMessage函数，添加解析逻辑：

template<int ID, template<typename> typename MemFunc>
void handleMessage(NamePrinter& printer, const std::byte* data, size_t dataSize) {
    using MsgT = MsgTypeFromID_t<ID>;
    MsgT msg;
    // 替换为实际的字节解析逻辑，比如 memcpy 或自定义解析函数
    // std::memcpy(&msg, data, sizeof(MsgT));
    std::invoke(MemFunc{}, printer, msg);
}

// 对应的通用分发函数修改参数：
template<template<typename> typename MemFunc>
void intToFunc(NamePrinter& printer, int msgId, const std::byte* data, size_t dataSize) {
    static constexpr std::array<void(*)(NamePrinter&, const std::byte*, size_t), 4> funcTable = {
        nullptr,
        handleMessage<1, MemFunc>,
        handleMessage<2, MemFunc>,
        handleMessage<3, MemFunc>
    };

    if (msgId >=1 && msgId <=3 && funcTable[msgId]) {
        funcTable[msgId](printer, data, dataSize);
    } else {
        std::cerr << "Invalid message ID: " << msgId << "\n";
    }
}

为什么之前的编译失败？ #

通常是因为直接传递模板成员函数时，编译器无法推导模板参数，或者没有将模板成员函数转化为可实例化的实体。上面的方案通过模板特化的类型映射和编译期函数表，明确指定了每个ID对应的消息类型和成员函数实例，解决了模板参数推导的问题。

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