将类型信息传递给函数代替虚拟模板函数 C++

Question

我有一个实现以下内容的基类：

struct Consumer
{
    template <typename T>
    void callback(T msg) { /*null implementation */ }
};

然后我有一个类实现这个：

struct Client : public Consumer
{
     void callback(Msg1 msg);
     void callback(Msg2 msg);
     void callback(Msg3 msg);
};

问题是我有一个被视为 Consumer* 的 Client 对象容器，我想不出一种方法让这些 Consumer 对象调用派生对象功能。我的预期功能是拥有多个客户端，每个客户端都为每个 Msg 类实现一个重载函数，这对它们来说意味着一些东西，其余的调用只需调用基类中的 null 实现

任何想法我如何才能使派生类成为叫？现在我需要实现 Consumer 中的每个重载函数并将它们标记为虚拟。

干杯， 格雷姆

Answer 1

如果您真的不想使用虚函数（实际上这似乎是它们的完美用例，但我不知道您的消息类），您可以使用 CRTP：

template <typename U>
struct Consumer
{
    template <typename T>
    void callback(T msg)
    { static_cast<U*>(this)->callback(msg); }
};


struct Client : Consumer<Client>
{
     void callback(Msg1 msg);
     void callback(Msg2 msg);
     void callback(Msg3 msg);
};

当然，问题是您无法再在容器中存储 Consumer 对象。由于一切都是编译时的，因此客户端的实际类型必须与消费者对象一起存储，以便编译器调用正确的回调函数。虚函数允许您等到运行时...

是否有理由不让 Msg 类多态并使用标准虚函数（除了“我必须重写所有代码，但我不能”） ）？

编辑如果您关心的是消息类，为什么不使用类似的东西，假设消息类实现 DoSomething 成员函数：（这种技术称为类型擦除）

struct AnyMsg
{
    template <typename Msg>
    AnyMsg(Msg x) : impl(newImpl(x)) {}

    void DoSomething() { impl->DoSomething(); }

private:
    struct Impl
    {
        virtual ~Impl() {}
        virtual void DoSomething() = 0;
    };

    // Probably better is std::unique_ptr if you have
    // C++0x. Or `boost::scoped_ptr`, but you have to
    // provide copy constructors yourself.
    boost::shared_ptr<Impl> impl;

    template <typename Msg>
    Impl* newImpl(Msg m)
    {
        class C : public Impl
        {
            void DoSomething() { x.DoSomething(); }
            Msg x;

        public:
            C(Msg x) : x(x) {}
        };

        return new C(m);
    }
};

您可以自定义 newImpl 的行为来获得您想要的（例如，如果消息类中没有 DoSomething 成员函数，则默认操作，专门化一些消息类或其他）。这样，您就可以像使用模板解决方案一样实现 Msg 类，并且拥有一个可以传递给客户端类中的虚拟函数的独特外观。

如果消息类将非常不同，并且客户端类可能对它们做出不同的反应，并且您将有很多消息类，那么这就开始变得难闻了。或者也许您有一个丑陋而可怕的访问者模式的候选者。

Answer 2

由于您不想使用虚拟方法，因此编译器必须静态地（即在编译时）知道要调用哪个函数。如果容器中有不同的客户端对象，编译器现在可能会知道这一点。所以我认为如果不使用虚拟方法就无法解决你的问题（顺便说一句，这些方法是专门为这种情况设计的......）。

当然，您也可以使用一些 switch 语句来手动派生具体类型，但这既不优雅也不高效（并且您必须对所有可能的客户端类型进行硬编码......）

编辑< /strong>

就个人而言，我会实现一些包含类型代码的基本消息类，并在客户端类中实现 switch 语句来处理不同的消息类型，例如：

struct MsgBase {
   int type;
};

struct Consumer {
   virtual void callback(MsgBase msg) { };
};

struct Client : public Consumer {
    void callback(MsgBase msg) {
        switch (msg.type) {
        case MSGTYPE1:
           callback((Msg1)msg);
           break;
        case MSGTYPE2:
           callback((Msg2)msg);
           break;
        // ...
        }
   }
   void callback(Msg1 msg) { /* ... */ }
   void callback(Msg2 msg) { /* ... */ }
};

您还可以制作 MsgBase code> 多态（例如虚拟析构函数）并使用 typeid 来区分（更优雅但效率稍低......）

struct Client : public Consumer {
    void callback(MsgBase* msg) {
        if (typeid(*msg) == typeof(Msg1))
           callback(static_cast<Msg1*>(msg));
        else if (typeid(*msg) == typeof(Msg2))
           callback(static_cast<Msg2*>(msg));
    }
    // ...
 };

Answer 3

要实现完全可扩展始终是一个困难的情况，就像访问者模式通常的情况一样。

您最终需要最多 V*T 实现，其中 V 是“访问者”的数量，T 是被访问的类型的数量，并且最终可能不得不使用访问者和类工厂模式的混合。

这里的访客将是您的消费者
类工厂将用于消息类型。

使其完全可扩展的最佳方法是为消息/消费者对创建新的函数“对象”，并进行一些双重调度以确保正确的函数被调用。

在您的情况下，您收到不同的消息，然后将它们提供给可能处理它们的消费者？所以每条消息都应该有一个可识别的“类型”和你的消费者
应该在表中查找此类型以为其创建处理程序。

每个消费者类的每种类型可以有一个处理程序。