C++中转换void*处理异构消息有没有更符合惯用规范的实现方式？

可选的优化方案 #

以下两种是C++生态中处理这类带类型标记异构消息的常用惯用实现，可替代冗长的switch分支：

方案1：处理函数注册表（全版本C++通用，工程实践最常用） #

核心思路是把消息类型和对应的处理逻辑做映射，消除重复的类型转换代码，新增类型不需要修改核心处理流程，符合开闭原则。

// 定义统一的处理函数签名
using MsgHandler = std::function<void(void*)>;
// 全局/类成员的处理函数映射表
std::unordered_map<MessageTypes, MsgHandler> handler_map;

// 初始化阶段一次性注册所有类型的处理逻辑
void init_handlers() {
    // 注：原代码中std::static_pointer_cast仅适用于智能指针转换，void*裸指针直接用static_cast即可
    handler_map[MessageTypes::TYPE_A] = [](void* data) {
        auto* typed_msg = static_cast<Type_A*>(data);
        std::cout << typed_msg->value << std::endl;
    };
    handler_map[MessageTypes::TYPE_B] = [](void* data) {
        auto* typed_msg = static_cast<Type_B*>(data);
        std::cout << typed_msg->number << std::endl;
        std::cout << typed_msg->value << std::endl;
    };
    handler_map[MessageTypes::TYPE_C] = [](void* data) {
        auto* typed_msg = static_cast<Type_C*>(data);
        std::cout << typed_msg->value << std::endl;
        std::cout << typed_msg->word << std::endl;
    };
}

核心处理逻辑可简化为：

void process_messages(void) {
    init_handlers(); // 初始化仅执行一次，可移出循环
    while (true) {
        if (!message_queue.empty()) {
            auto msg = message_queue.front();
            message_queue.pop();
            auto type = msg.first;
            auto content = msg.second;
            
            // 直接查表调用，无硬编码类型分支
            if (handler_map.count(type)) {
                handler_map[type](content);
            } else {
                // 可选：未识别类型兜底逻辑
            }
        }
    }
}

该方案优势：

• 新增消息类型仅需新增注册代码，核心处理逻辑完全不需要改动
• 每个类型的处理逻辑内聚，代码可读性更高
• 性能和switch方案几乎无差异，哈希表查找开销可忽略

方案2：std::variant + 访问者模式（C++17及以上推荐，类型更安全） #

如果项目允许调整消息队列的存储逻辑，该方案可以完全避免裸void*操作，类型安全性由编译器保证：

// 首先定义所有可能的消息类型变体
using MsgVariant = std::variant<Type_A*, Type_B*, Type_C*>;

// 定义消息访问者
struct MsgVisitor {
    void operator()(Type_A* msg) const {
        std::cout << msg->value << std::endl;
    }
    void operator()(Type_B* msg) const {
        std::cout << msg->number << std::endl;
        std::cout << msg->value << std::endl;
    }
    void operator()(Type_C* msg) const {
        std::cout << msg->value << std::endl;
        std::cout << msg->word << std::endl;
    }
};

处理时直接调用std::visit即可：

// 出队后先根据类型标记把void*转成对应类型存入variant
MsgVariant var;
switch(type) {
    case MessageTypes::TYPE_A: var = static_cast<Type_A*>(content); break;
    case MessageTypes::TYPE_B: var = static_cast<Type_B*>(content); break;
    case MessageTypes::TYPE_C: var = static_cast<Type_C*>(content); break;
}
std::visit(MsgVisitor{}, var);

如果支持C++20，还可以用泛型lambda简化访问者的编写。

原方案说明 #

你当前使用的switch方案本身没有语法错误，但可维护性较差，新增类型容易漏改分支，不适合消息类型迭代频繁的工程场景。

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