如何避免在通过队列传递信息时向下转换

> 您可以尝试访客设计模式： http://en.wikipedia.org/wiki/Visitor_pattern

每个 DataProcessor 都将继承自一个 BaseVisitor 类，该类定义了处理每种消息类型的虚拟方法。基本上这些方法只是noop。

定义新的消息类型时，您将在 BaseVisitor 中添加一个新的虚拟方法，其中包含此消息类型的 noop 实现。然后，如果子类DataProcessor想要处理此消息类型，则仅覆盖此DataProcessor中的虚拟方法。所有其他DataProcessor保持不变。

    #include <iostream>

    class FocalLength;
    class Angle;
    class EquipmentVisitor;
    class QueuedItem
    {
    public:
            QueuedItem() { }
            virtual ~QueuedItem() { }
            virtual void AcceptVisitor(EquipmentVisitor& visitor) = 0;
    };
    class EquipmentVisitor
    {
    public:
            virtual ~EquipmentVisitor() {}
            virtual void Visit(FocalLength& item) {}
            virtual void Visit(Angle& item)       {}
            void ProcessMessages(QueuedItem* item)
            {
                    item->AcceptVisitor(*this);
            }
    };
    class Angle : public QueuedItem
    {
    public:
            Angle() {}
            virtual ~Angle() { }
            void AcceptVisitor(EquipmentVisitor& visitor) { visitor.Visit(*this); }
    };
    class FocalLength : public QueuedItem
    {
    public:
            FocalLength() {}
            virtual ~FocalLength() { }
            void AcceptVisitor(EquipmentVisitor& visitor) { visitor.Visit(*this); }
    private:
    };
    class MyDataProcessor : public EquipmentVisitor
    {
    public:
            virtual ~MyDataProcessor() {}
            void Visit(Angle& angle)             { std::cout << "Processing Angle" << std::endl; }
            void Visit(FocalLength& focalLength) { std::cout << "Processing FocalLength" << std::endl; }
    };

    int main(int argc, char const* argv[])
    {
            // Equipment interface thread...
            FocalLength* f    = new FocalLength();
            QueuedItem*  item = f; // This gets stuck onto the queue
            // ...DataProcessor thread (after dequeuing)
            QueuedItem* dequeuedItem = item;
            // Example of a DataProcessor implementation.
            // In reality, this would
            MyDataProcessor dataProc;
            dataProc.ProcessMessages(dequeuedItem);
            return 0;
    }

您可以执行以下任一操作：

将处理代码（如 switch 语句中的每个case）委托给Handler对象 - 可以是HandlerBase对象的层次结构，也可以是完全不相关的类型。

然后，您让消息保留对Handler对象的引用（如果它是一个层次结构，则可以在BaseMessage级别执行此操作，如果不相关的对象，则作为各个专用消息类型的一部分），然后您可以在处理它们时通过BaseMessage::Handle()方法将它们传递给该对象。编辑：此方法不是虚拟的。

当然，如果你沿着HandlerBase层次结构的道路走下去，你仍然需要将消息static_cast回它们是什么类型，但这应该没问题：无论如何，它们应该只使用自己的 Handler（应该知道它们的类型）创建。

例：

// BaseMessage.hpp
#include <iostream>
class BaseMessage
{
public:
  BaseMessage(HandlerBase* pHandler);
  : m_pHandler(pHandler)
  {}
  virtual ~BaseMessage()
  {}
  void  SetHandler(HandlerBase* pHandler)
  {
    m_pHandler = pHandler;
  }
  void  Handle()
  {
    assert(m_pHandler != 0);
    m_pHandler->Handle(this);
  }
protected:
  HandlerBase*  m_pHandler; // does not own it - can be shared between messages
};
// HandlerBase.hpp
class HandlerBase
{
public:
  HandlerBase()
  {}
  virtual ~HandlerBase()
  {}
  virtual void Handler(BaseMessage* pMessage) =0;
}
// message and handler implementations
class AMessage: public BaseMessage
{
public:
  AMessage(BaseHandler* pHandler)
    : BaseMessage(pHandler)
  {}
  ~AMessage() {}
  void  DoSomeAness()
  {
    std::cout << "Being an A..." << std::endl;
  }
};
class AHandler
{
public:
  AHandler()
  {}
  virtual ~AHandler()
  {}
  virtual void Handle(BaseMessage* pMessage)
  {
    AMessage *pMsgA(static_cast<AMessage*>(pMessage));
    pMsgA->DoSomeAness();
  }
};
class BMessage: public BaseMessage
{
public:
  BMessage(BaseHandler* pHandler)
    : BaseMessage(pHandler)
  {}
  ~BMessage() {}
  void  DoSomeBness()
  {
    std::cout << "Being a B..." << std::endl;
  }
};
class BHandler
{
public:
  BHandler()
  {}
  virtual ~BHandler()
  {}
  virtual void Handle(BaseMessage* pMessage)
  {
    BMessage *pMsgB(static_cast<BMessage*>(pMessage));
    pMsgB->DoSomeBness();
  }
};

// the thread
static std::list<BaseMessage*> msgQueue;
int HandlerThread(void *pData)
{
  while(true)   // find some more sophisticated way to break
  {
    while(!msgQueue.empty())
    {
      msgQueue.front()->Handle();
      msgQueue.pop_front();
    }
    // delay and stuff
  }
  return 0;
}
int main(int argc, char** argv)
{
  start_thread(HandlerThread, 0); // your favorite API here
  AHandler  aHandler;
  BHandler  bHandler;
  msqQueue.push_back(new AMessage(&aHandler));
  msqQueue.push_back(new BMessage(&bHandler));
  msqQueue.push_back(new BMessage(&bHandler));
  msqQueue.push_back(new AMessage(&aHandler));
  msqQueue.push_back(new AMessage(&aHandler));
  msqQueue.push_back(new BMessage(&bHandler));
  msqQueue.push_back(new AMessage(&aHandler));
  msqQueue.push_back(new BMessage(&bHandler));
  return 0;
}

编辑：是的，本质上，这是访问者模式。

根据我的说法，最简单的消息处理，用于向 4 个处理程序发送 2 条消息：

#include <iostream>
#include <queue>
#include <memory>
class HandlerA
{
public:
  void doA1() { std::cout << "A1n"; }
  void doA2(const std::string& s) { std::cout << "A2: " << s << "n"; }
};
class HandlerB
{
public:
  void doB1() { std::cout << "B1n"; }
  void doB2(const std::string& s) { std::cout << "B2: " << s << "n"; }
};

class BaseMsg
{
public:
  virtual ~BaseMsg() {}
  void send();
  virtual void handle() { execute(); }
  virtual void execute() = 0;
};
typedef std::shared_ptr<BaseMsg> Msg;
class Medium
{
  std::queue<Msg> queue;
public:
  void send(Msg msg) { queue.push(msg); }
  void process()
  {
    while (! queue.empty())
    {
      std::cout << "Processingn";
      queue.front()->handle();
      queue.pop();
    }
  }
};
class BaseMsgHndlrA : public BaseMsg
{
protected:
  HandlerA& ha;
public:
  BaseMsgHndlrA(HandlerA& ha_) : ha(ha_) { }
};
class BaseMsgHndlrB : public BaseMsg
{
protected:
  HandlerB& hb;
public:
  BaseMsgHndlrB(HandlerB& hb_) : hb(hb_) { }
};
class MsgA1 : public BaseMsgHndlrA
{
public:
  MsgA1(HandlerA& ha_) : BaseMsgHndlrA(ha_) { }
  virtual void execute() { ha.doA1(); } 
};
class MsgA2 : public BaseMsgHndlrA
{
public:
  MsgA2(HandlerA& ha_) : BaseMsgHndlrA(ha_) { }
  virtual void execute() { ha.doA2("Msg A2"); } 
};
class MsgB1 : public BaseMsgHndlrB
{
public:
  MsgB1(HandlerB& hb_) : BaseMsgHndlrB(hb_) { }
  virtual void execute() { hb.doB1(); } 
};
class MsgB2 : public BaseMsgHndlrB
{
  std::string s;
public:
  MsgB2(HandlerB& hb_, const std::string s_) : BaseMsgHndlrB(hb_), s(s_) { }
  virtual void execute() { hb.doB2(s); } 
};
int main()
{
  Medium medium;
  HandlerA handlerA;
  HandlerB handlerB;
  medium.send(Msg(new MsgA1(handlerA)));
  medium.send(Msg(new MsgA2(handlerA)));
  medium.send(Msg(new MsgB1(handlerB)));
  medium.send(Msg(new MsgB2(handlerB, "From main")));
  medium.process();
}

这仅使用虚拟函数调度到带有某些参数的正确处理程序。
handle（） 函数不是严格需要的，但在定义消息层次结构时很有用。
通用消息可以包含可以使用绑定填充的 std：：函数，因此可以发送带有参数的实际函数，而不是为每个排队的操作创建一个消息类。
为了隐藏实际的发送，处理程序可以自己执行发送，因此可以从发送线程立即访问它们。

但是，如果需要将多个消息发送到更多处理程序，则可以使用双重调度（访问者）。