C++：如何构建没有空指针的事件/消息系统？

Question

我希望在我的 C++ 项目中拥有一个动态消息传递系统，其中有一个固定的现有事件列表，事件可以在运行时的任何地方触发，并且您可以在其中订阅某些事件的回调函数。

应该有一个选项可以在这些事件中传递参数。例如，一个事件可能不需要任何参数 (EVENT_EXIT)，而有些事件可能需要多个 (EVENT_PLAYER_CHAT: 玩家对象指针，带有消息的字符串)

第一个选项这可能是允许在触发事件时将 void 指针作为参数传递给事件管理器，并在回调函数中接收它。

虽然：我被告知 void 指针是不安全的，我不应该使用它们。

• 如何在不使用 void 指针的情况下保留事件的（半）动态参数类型和计数？

Answer 1

由于其他人已经提到了访问者模式，这里使用 Boost 进行了轻微的改动.变体。当您需要一组基于值的不同行为时，这个库通常是一个不错的选择（或者至少对我来说是这样）。与 void* 相比，它具有静态类型检查的优点：如果您编写的访问者类错过了其中一种情况，您的代码将不会编译而不是失败在运行时。

步骤 1： 定义消息类型：

struct EVENT_EXIT { }; // just a tag, really
struct EVENT_PLAYER_CHAT { Player * p; std::string msg; };

typedef boost::variant<EVENT_EXIT,
                       EVENT_PLAYER_CHAT> event;

步骤 2： 定义访问者：

struct event_handler : public boost::static_visitor<void> {
  void operator()(EVENT_EXIT const& e) {
    // handle exit event here
  }

  void operator()(EVENT_PLAYER_CHAT const& e) {
    // handle chat event here
    std::cout << e.msg << std::endl;
  }
};

这定义了一个事件处理程序，可以很好地分离每种事件的代码。所有 operator() 重载的存在都会在编译时（在模板实例化时）进行检查，因此如果您稍后添加事件类型，编译器将强制您添加相应的处理程序代码。

请注意，event_handler 是 boost::static_visitor 的子类。这决定了每个 operator() 重载的返回类型。

第 3 步：使用事件处理程序：

event_handler handler;
// ...
event const& e = get_event(); //variant type
boost::apply_visitor(handler, e); // will not compile unless handler
                                  // implements operator() for each
                                  // kind of event

这里，apply_visitor 将为 e 的“实际”值调用适当的重载。例如，如果我们定义 get_event 如下：

event get_event() {
  return EXIT_EVENT();
}

那么返回值将隐式转换为 event(EXIT_EVENT())。然后apply_visitor将调用相应的operator()(EXIT_EVENT const&)重载。

Answer 2

模板允许您编写类型安全的事件管理器，而无需先验了解消息类型。

如果事件类型在运行时发生变化，或者您需要将多种类型混合到一个容器中，则可以使用指向所有消息/事件类型的公共基类的指针。

Answer 3

我过去所做的事情是使用（优秀的）FastDelegate 库建立一个基于委托的系统，与 C# 中的系统不同：http://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Possible

因此，有了这些，我创建了一些通用的事件类来包含委托列表，如下所示：

template <class T1>
class Event1 {
public:
    typedef FastDelegate1<T1> Delegate;
private:
    std::vector<Delegate> m_delegates;
public:
    // ...operator() to invoke, operators += and -= to add/remove subscriptions
};

// ...more explicit specializations for diff arg counts (Event2, etc.), unfortunately

然后，您可以让各种子组件公开其特定的事件对象（我使用了接口样式，但这不是必需的)：

typedef Event2<Player*, std::string> PlayerChatEvent;

class IPlayerEvents {
public:
    virtual PlayerChatEvent& OnPlayerChat() = 0;
    virtual PlayerLogoutEvent& OnPlayerLogout() = 0; // etc...
};

该接口的使用者可以像这样注册：

void OtherClass::Subscribe(IPlayerEvent& evts) {
    evts.OnPlayerChat() += MakeDelegate(this, &OtherClass::OnPlayerChat);
}

void OtherClass::OnPlayerChat(Player* player, std::string message) {
    // handle it...
}

结果是每个事件类型都是单独静态类型的——没有动态类型转换。然而，它确实分散了事件系统，这对于您的架构来说可能是也可能不是问题。

Answer 4

您可以使用基类（可选的抽象类）并使用dynamic_cast。该参数将在运行时进行检查。不过，编译时可能会更好。

class EventArgs
{
public:
   virtual ~EventArgs();
};

class PlayerChatEventArgs : public EventArgs
{
public:
   PlayerChatEventArgs(Player* player, const std::string& message);
   virtual ~PlayerChatEventArgs();
   Player* GetPlayer() const;
   const std::string& GetMessage() const;
private:
   Player* player;
   std::string message;
};

class Event
{
public:
   virtual ~Event() = 0;
   virtual void Handle(const EventArgs& args) = 0;
};

class ExitEvent : public Event
{
public:
   virtual ~ExitEvent();
   virtual void Handle(const EventArgs& /*args*/)
   {
      // Perform exit stuff.
   }
};

class PlayerChatEvent : public Event
{
public:
   virtual ~PlayerChatEvent();
   virtual void Handle(const EventArgs& args)
   {
      // this will throw a bad_cast exception if cast fails.
      const PlayerChatEventArgs& playerchatargs =
         dynamic_cast<const PlayerChatEventArgs&>(args);
      // Perform player chat stuff.
   }
};

Answer 5

我会考虑为消息建立一个基类，然后从该基类派生所有消息。然后，您将围绕事件传递指向基类的指针。

您可能会在基类中拥有一些基本功能，其中可能包括一个成员，说明它是什么类型的消息。这将允许您在转换到您需要的版本之前检查消息类型。

将基类作为最基本的消息类型很诱人，但我建议将其设为虚拟类，以便每个消息都必须进行强制转换才能使用。当复杂性（不可避免地）增加时，这种对称性使其更不容易出现错误