C++ 多态性 : what am I missing?

Question

我正在学习 C++，并希望构建类似于 C# 事件的东西来处理嵌入式 C++ 项目中的中断。

到目前为止，我想出了一个几乎可以满足我要求的解决方案。但是我需要一些关于多态性的帮助(？)。以下代码片段是重现我的情况的最小示例:

#include <iostream>       

struct Event
  { };

struct EventHandler
  {
    virtual void Esr (const Event& I) { }
  };

struct EventSender
  {
    EventSender (EventHandler& Handler) : _Handler (Handler) { }

    template <typename T>
    void SendEvent (const T&) const
      {
        _Handler.Esr (T ());
      }

    EventHandler& _Handler;
  };

struct SpecialEvent : public Event
  { };

struct MyHandler : public EventHandler
  {
    void Esr (const Event& I) override { std::cout << "Event" << std::endl; }
    void Esr (const SpecialEvent& I) { std::cout << "SpecialEvent" << std::endl; }
  };            

int main()
  {
    MyHandler handler;
    EventSender sender (handler);

    /* Invoke directly  */
    handler.Esr (Event ());
    handler.Esr (SpecialEvent ());

    /* Invoke indirectly  */
    sender.SendEvent (Event ());
    sender.SendEvent (SpecialEvent ());  // Expected cout msg: "SpecialEvent"

    return 0;
  }

预期的控制台输出:

Event
SpecialEvent
Event
SpecialEvent

实际控制台输出:

Event
SpecialEvent
Event
Event

我不知道的编译器/链接器是什么？

Answer 1

在这里您尝试使用重载，而不是经典的(基于虚函数的)多态性。

您想要的(至少据我所知)是在直接使用 handler 和通过 sender 间接调用它之间本质上相同的行为。发生的变化介于 Event 和 SpecialEvent 之间。

在这种情况下，经典多态性将涉及 Event 中的虚函数，该虚函数在 SpecialEvent 中被覆盖:

struct Event { 
    virtual void operator()() const { std::cout << "Event\n"; }
};

struct SpecialEvent : public Event { 
    virtual void operator()() const override { std::cout << "Special Event\n"; }
};

有了这个，对 Event 的引用(或指针)将调用实际类型的成员。在这里进行多态意味着我们只需要一个处理程序类，所以代码最终是这样的:

#include <iostream>

struct Event { 
    virtual void operator()() const { std::cout << "Event\n"; }
};

struct EventHandler {
    void Esr(const Event& I) const { I(); }
};

struct EventSender {
    template <typename T>
    void SendEvent (const T& t) const {
        handler.Esr(t);
    }

    EventHandler handler;
};

struct SpecialEvent : public Event { 
    virtual void operator()() const override { std::cout << "Special Event\n"; }
};

int main() {
    EventHandler handler;
    EventSender sender;

    /* Invoke directly  */
    handler.Esr (Event ());
    handler.Esr (SpecialEvent ());

    /* Invoke indirectly  */
    sender.SendEvent (Event ());
    sender.SendEvent (SpecialEvent ());  // Expected cout msg: "SpecialEvent"
}