C ++选择基于方法的参数的动态类型

Question

问题

假设我有一些模拟器库，它从我这里获取一些对象（也称为事件处理程序）并通过调用它们的 handle_event(Event) 方法为这些对象生成事件。该库为我提供了以下类：

class Event {}; // Base class for all events
// All event classes are derived from `Event`
class SomeParticularEvent : public Event {}; // Some event class
class AnotherParticularEvent : public Event {}; // Some event class


// Object aka event handler. I should inherit this class and then give objects to the simulator
class AbstractEventHandler
{
public:
        virtual void handle_event(Event) = 0;
};

我想实现一个以不同方式处理不同事件的对象。我想出的第一个代码如下：

#include <iostream>

class MyObject : public AbstractEventHandler
{
public:
        void actual_handle_event(SomeParticularEvent)
        {
                std::cout << "`SomeParticularEvent` occurred\n";
        }

        void actual_handle_event(AnotherParticularEvent)
        {
                std::cout << "`AnotherParticularEvent` occurred\n";
        }

        void actual_handle_event(Event e)
        {
                std::cerr << "Unknown event type occurred\n";
        }

        virtual void handle_event(Event e) override
        {   
                actual_handle_event(e);
        }   
};

С 出乎我的意料，MyObject::handle_event(Event) 将始终调用MyObject::actual_handle_event(Event)，而不管e 的动态类型如何。

我的问题是：实现MyObject 的正确方法是什么（最好是可以轻松添加新的事件类型）？

---

所有代码放在一起

#include <iostream>


class Event {}; // Base class for all events
// All event classes are derived from `Event`
class SomeParticularEvent : public Event {}; // Some event class
class AnotherParticularEvent : public Event {}; // Some event class


class AbstractEventHandler
{
public:
        virtual void handle_event(Event) = 0;
};


class MyObject : public AbstractEventHandler
{
public:
        void actual_handle_event(SomeParticularEvent)
        {
                std::cout << "`SomeParticularEvent` occurred\n";
        }

        void actual_handle_event(AnotherParticularEvent)
        {
                std::cout << "`AnotherParticularEvent` occurred\n";
        }

        void actual_handle_event(Event e)
        {
                std::cerr << "Unknown event type occurred\n";
        }

        virtual void handle_event(Event e) override
        {
                actual_handle_event(e);
        }
};


int main()
{
        MyObject o{};
        o.handle_event(SomeParticularEvent{}); // Prints "Unknown event type occurred"
}

---

其他问题

是否也可以创建一个派生自MyObject 的类并实现附加 事件处理程序（不覆盖旧的，但添加对新事件的支持）而不重写handle_event 中的方法派生类？

Answer 1

基于问题中的要求以及在@ypnos 回答的cmets 中讨论的内容，我相信您希望或需要在这里实现访问者模式。

一种可能的实现如下所示（基于关于访问者模式的 Wikipedia 文章：https://en.wikipedia.org/wiki/Visitor_pattern#C++_example）

#include <iostream>

// Forward declare all Event classes
class Event;
class SomeParticularEvent;
class AnotherParticularEvent;

class AbstractEventHandler
{
public:
        virtual void handle_event(const Event&) = 0;
        virtual void handle_event(const SomeParticularEvent&) = 0;
        virtual void handle_event(const AnotherParticularEvent&) = 0;
};

class Event {
public:
    // virtual function for accepting the "visitor"
    virtual void accept(AbstractEventHandler& handler) {
        handler.handle_event(*this);
    }
}; // Base class for all events
// All event classes are derived from `Event`
class SomeParticularEvent : public Event {
public:
    // Needs to be overriden to call `handle_event` with the correct type
    void accept(AbstractEventHandler& handler) override {
        handler.handle_event(*this);
    }
}; // Some event class
class AnotherParticularEvent : public Event {
public:
    void accept(AbstractEventHandler& handler) override {
        handler.handle_event(*this);
    }
}; // Some event class

class MyObject : public AbstractEventHandler
{
public:
        void handle_event(const SomeParticularEvent&) override
        {
                std::cout << "`SomeParticularEvent` occurred\n";
        }

        void handle_event(const AnotherParticularEvent&) override
        {
                std::cout << "`AnotherParticularEvent` occurred\n";
        }

        void handle_event(const Event& e) override
        {
                std::cerr << "Unknown event type occurred\n";
        }
};


int main()
{
        MyObject o{};
        SomeParticularEvent{}.accept(o);
        AnotherParticularEvent{}.accept(o);
}

Answer 2

在您的方法handle_event() 中发生对象切片。您应该传递 (const) 引用以使继承正常工作，或者传递指针。

但是，在从 handle_event() 内部调度到 actual_handle_event() 时，这对您的情况没有帮助。

蛮力解决方案是通过尝试dynamic_casts 显式调度。您需要在派生类中覆盖 handle_event() 来扩展它。它看起来也不那么漂亮（表明存在设计问题）。

在这些情况下通常会做的是，有问题的对象 (Event) 将提供一个用于查询类型的接口，例如被覆盖的抽象 type() getter。