C++ 在派生类中调用正确的重载

考虑以下几点

struct Message
{
  Message() : description("Generic message") {}
  Message(const std::string& d) : description(d) {}

  std::string description;
};

struct MessageType1 : public Message
{
  MessageType1() : Message("MessageType1"), a_boolean(false) {}
  bool a_boolean;
};

// more specific Message types

class AbstractMessagePasser
{
 public:
  virtual ~AbstractMessagePasser();

  void receive(const Message& m) {}
};

class Component1
{
  AbstractMessagePasser* m_fwd;

 public:
  template<class M>
  void send(const M& m)
  {
    m_fwd->receive(m);
  }
};

// more classes like Component1 with a pointer to an AbstractMessagePasser

class MessagePasser : public AbstractMessagePasser
{
  Component1* cp1;
  Component2* cp2;

  using AbstractMessagePasser::receive;      

  // overloads of AbstractMessagePasser::receive() for different message types
  void receive(const MessageType1&)
  {
    // do something
  }

  void receive(const MessageType2&)
  {
    // do something different
  }
};

struct消息
{
Message（）：说明（“通用消息”）{}
消息（const std:：string&d）：描述（d）{
std：：字符串描述；
};
结构MessageType1：公共消息
{
MessageType1（）：Message（“MessageType1”），一个布尔值（false）{
布尔布尔；
};
//更具体的消息类型
类AbstractMessagePasser
{
公众：
虚拟~AbstractMessagePasser（）；
无效接收（const Message&m）{}
};
类组件1
{
AbstractMessagePasser*m_fwd；
公众：
模板
无效发送（常量M&M）
{
m_前进->接收（m）；
}
};
//更多类似Component1的类，带有指向AbstractMessagePasser的指针
类MessagePasser:public AbstractMessagePasser
{
组件1*cp1；
成分2*cp2；
使用AbstractMessagePasser:：receive；
//不同消息类型的AbstractMessagePasser:：receive（）重载
无效接收（const MessageType1&）
{
//做点什么
}
无效接收（const MessageType2&）
{
//做些不同的事情
}
};

换句话说，我有一些组件，它们之间的通信是使用不同派生类型的

消息来完成的。所有通信都应在
MessagePasser
中处理。为此，我希望
MessagePasser
在组件发送
Message
时调用
receive（）
的正确重载，即如果组件调用
send（const MessageType1&）
则
receive（const MessageType1）
应在
MessagePasser
中调用。但是，始终调用基类版本

我也尝试过模板专门化，但没有成功（在
AbstractMessagePasser
中模板化
receive
。有没有一种简单的方法来实现这一点？
您必须使receive方法虚拟化。否则它只是一个静态函数调用

class AbstractMessagePasser
{
public:
    virtual ~AbstractMessagePasser();

    virtual void receive(const Message& m) {}
};

关键词：动态调度。如果所有通信都应该在
MessagePasser
中处理，为什么
AbstractMessagePasser
存在？