Question

我正在编写一些消息处理代码，其中每条消息都是POD结构。在写作方式上，这将是定义一个抽象基类，每个消息类型都有虚拟函数，例如：

class AbstractHandler
{
public:
    virtual void handleMessage( const MessageType1& msg ) =0;
    virtual void handleMessage( const MessageType2& msg ) =0;
    virtual void handleMessage( const MessageType3& msg ) =0;
    virtual void handleMessage( const MessageType4& msg ) =0;
};

然后创建实现处理函数的派生具体类：

class ConcreteHandler : public AbstractHandler
{
public:
    virtual void handleMessage( const MessageType1& msg );
    virtual void handleMessage( const MessageType2& msg );
    virtual void handleMessage( const MessageType3& msg );
    virtual void handleMessage( const MessageType4& msg );
};

如果系统添加了新消息AbstractHandler，则必须同时更新所有派生类型。

或者，我可以在mpl序列中保存所有支持的消息类型，并使用mpl::inherit_linearly生成抽象基类。

（注意：我已经在代码的其他地方使用了mpl::vector个消息类型。）

e.g：

typedef mpl::vector< MessageType1, MessageType2, 
                     MessageType3, MessageType4 > message_types;

template< class Message >
class Wrapper
{
public:
   virtual void handleMessage( const Message& msg ) = 0;
protected:
   ~Wrapper(){}
};

class AbstractHandler 
     : public mpl::inherit_linearly< message_types
                                   , mpl::inherit< mpl_1, Wrapper< mpl::_2 > >
                                   >::type
{
public:
    virtual ~AbstractHandler() {}
};

然后，具体处理程序派生自AbstractHandler。这意味着每当向系统添加新的消息类型时，只需更改mpl::vector< types... > message_types序列，添加新的handleMessage函数添加到派生类。

在我看来，这减少了长期维护，因为AbstractHandler会自动为mpl::vector message_types

中的所有消息提供纯虚函数

在性能方面，使用这种方法有什么缺点吗？

使用mpl::inherit_linearly生成抽象基类有什么含义？

Answer 1

之前我做过类似的代码（今天我又做了）。

除了继承引起的成本之外没有其他成本。主要是因为最终类型是在编译时确定的，而不是运行时。

但是，相对于消息类型列表大小，这显然会使编译时间更长。如果像我一样你也编写了一个消息调度程序类（可以将任何东西分派给这种类型的任何处理程序），那么在编译时它可能会很昂贵。

否则，这很好。

理解这种设置的含义：处理的消息列表是在编译时定义的，而不是运行时定义的。由于使用要求，某些事件系统是运行时。因此，请确保在您的用例中使用它。

使用mpl :: inherit_linearly定义接口的含义

1 个答案: