C++中的事件分发

　　本文意在展现一个C++实现的通用事件分发系统，能够灵活的处理各种事件。对于事件处理函数的注册，希望既能注册到普通函数，注册到事件处理类，也能注册到任意类的成员函数。这样在游戏客户端的逻辑处理中，可以非常灵活的处理事件，让普通函数和类的成员函数既能手动调用，又能作为事件响应函数。

　　游戏是一个交互很强的软件。在客户端中，事件充斥于整个程序的各个角落，玩家操作事件，网络消息事件，音频事件，定时事件等等。这些事件通常参数不一致，分属不同系统，使得消息的处理非常离散，分布于各个UI和系统类中。这使得在设计事件分发系统的时候，需要充分考虑通用性，能够适应各种处理函数需求。服务器在处理网络和数据库消息时，虽然通常是固定的处理格式，但同样需要实现一个统一的事件分发的机制。客户端C#有delegate的存在，因此可以非常方便的将成员函数绑定到delegate进行调用。在unity项目中，利用C#的这一特性，非常容易搭起事件系统框架。但是，C++项目由于常常有成员函数和普通函数并存，因此事件分发时，需要考虑到两种情况。

　　本文实现的事件分发系统是一个集中注册和分发的系统。消息的注册和分发都由EventManager单例负责，如果需要，可以在EventManager中加入EventQueue实现事件队列，进而缓存消息，异步分发。以下为EventManager类实现。

 #ifndef EVENTMANAGER_H
 #define EVENTMANAGER_H
 enum EventId
 {
     EVT_TICK = ,
 };

 struct Event
 {
     Event(int id) : id_(id)
     {}
     ~Event()
     {}
     int id_;
     //params
 };

 class EventHandler
 {
 public:
     virtual int HandleEvent(Event *evt)
     {
         return ;
     }
 };

 class EventManager
 {
 public:
     typedef std::list<EventHandler *> HandlerList;
     typedef std::map<int, HandlerList> IdHandlerMap;

 public:
     static EventManager &Instance()
     {
         static EventManager inst_;
         return inst_;
     }

     void AddEventHandler(int id, EventHandler *handler)
     {
         if (handler == NULL)
             return;
         auto pair = handler_map_.insert(std::make_pair(id, HandlerList()));
         auto it = pair.first;
         if (it == handler_map_.end())
             return;
         it->second.push_back(handler);
     }

     void RemoveEventHandler(int id, EventHandler *handler)
     {
         if (handler == NULL)
             return;
         auto it = handler_map_.find(id);
         if (it == handler_map_.end())
             return;
         auto listIt = std::find(it->second.begin(), it->second.end(), handler);
         if (listIt != it->second.end())
             it->second.erase(listIt);
      }

     void ClearEventHandler(int id)
     {
         handler_map_.erase(id);
     }

     void DispatchEvent(Event *evt)
     {
         auto it = handler_map_.find(evt->id_);
         if (it == handler_map_.end())
             return;
         auto &handler_list = it->second;
         for (auto listIt = handler_list.begin(); listIt != handler_list.end(); ++listIt)
         {
             if ((*listIt) == NULL) continue;
             (*listIt)->HandleEvent(evt);
         }
     }

 private:
     EventManager(){}
     EventManager(const EventManager&){}
     ~EventManager(){}

     IdHandlerMap handler_map_;
 };

 #endif

　　其中：

　　EventId是一个事件类型枚举，以区分不同类型的事件，这里我只定义一个用来举例的时钟TICK事件。

　　Event定义一个具体事件，它作为事件基类，仅有一个事件类型(id)。实际使用的事件类继承自Event，并添加需要的参数传递给事件处理函数。

　　EventHandler是事件处理基类，当有事件分发给某个Handler时，它做的就是调用HandleEvent(注意，这里一种Event可以同时注册分发给多个EventHandler依次处理，在客户端中常常需要将消息分发到多个地方处理)。

　　EventManager是集中的事件管理器，这里作为示例用简单单例实现，可以根据需求扩展。它只有一个成员变量，EventId到它的EventHandler列表的映射。主要功能：注册，解注册Handler和分发事件。

　　使用时，定义具体的Event类型和处理类，注册事件处理函数，分发事件即可。这里用TickEvent作为例子。

 #include "EventManager.h"

 struct TickEvent : Event
 {
     TickEvent() : Event(EVT_TICK), time_()
     {}
     ~TickEvent()
     {}
     time_t time_;
 };

 class TimeEventHandler : public EventHandler
 {
     virtual int HandleEvent(Event *evt)
     {
         TickEvent *tickEvt = (TickEvent*)evt;
         printf("time now: %d", (int)tickEvt->time_);
         return ;
     }
 };

 TickEvent tickEvt;
 TimeEventHandler timeHandler;
 EventManager::Instance().AddEventHandler(EVT_TICK, &timeHandler);
 EventManager::Instance().DispatchEvent(&tickEvt);
 EventManager::Instance().RemoveEventHandler(EVT_TICK, &timeHandler);

　　TimeEventHandler作为EVT_TICK事件的处理器，在HandleEvent中做相应的处理。

　　这里是一个专门的事件处理器类，那么普通类的成员函数中如何方便的处理相应的消息呢？如果每个需要处理消息的类都需要继承自TimeEventHandler并且实现一个HandleEvent，那么势必会有局限性，如不能响应多个消息、须多重继承。如果能直接注册成员函数，那真是太好了！

　　我们来看一个例子，一个UIClass类，OnEvent正是一个处理TICK事件的函数。我们当然可以额外定义一个普通函数作为响应回调，让特定的EventHandler持有对象，并调用该普通函数，在普通函数中再调用对象的成员函数。但是这样做势必使得整个项目的代码很冗余。

 template<class Type>
 class ClassEventHandler : public EventHandler
 {
 public:
     typedef int (Type::*HandlerFunc)(Event *evt);

 public:
     ClassEventHandler(Type *ptr, HandlerFunc func):
     pointer_(ptr),
     func_(func)
     {
     }
     virtual int HandleEvent(Event *evt)
     {
         if (pointer_ && func_)
             return (pointer_->*func_)(evt);
         return ;
     }
 private:
     Type *pointer_;
     HandlerFunc func_;
 };
 //test eventmanager
 class UIClass
 {
 public:
     UIClass()
     {
     }

     ~UIClass()
     {
     }

     int OnEvent(Event *evt)
     {
         TickEvent *tickEvt = (TickEvent*)evt;
         printf("uiclass event, time now: %d", (int)tickEvt->time_);
         return ;
     }
 };

 UIClass ui;
 ClassEventHandler<UIClass> evthandler(&ui, &UIClass::OnEvent);
 EventManager::Instance().AddEventHandler(EVT_TICK, &evthandler);
 EventManager::Instance().DispatchEvent(&tickEvt);
 EventManager::Instance().RemoveEventHandler(EVT_TICK, &evthandler);

　　如上定义一个处理类模板ClassEventHandler，继承自EventHandler，有两个成员变量，持有对象和对象的类成员函数，handler初始化时指定相应的对象和成员函数，HandleEvent时调用该成员函数。如此使用时，除了多一个类模板特例化，几乎不带来任何额外代码成本，不需要对UIClass做任何特殊处理，这正是我们想要看到的～

　　补上一个实例图，能够更简单的说明一个Event的处理过程：

　　如上，每个Event有一个特定的EventId，当有Event发送给EventManager处理时，根据EventId索引到相应的EventHandler的列表，借助EventHandler的模板，这些Handler既可以时一般函数，也可以是成员函数。

　　事件分发系统的实现有多种，也有一些是预先注册好相应的事件内容，分发时直接分发事件id等方式。私以为这种传递Event指针的方式是最灵活和通用的，可以传递任意消息，甚至可以实现消息的嵌套，递归传递消息。在客户端和服务器都能有一致的应用，这对于后期想共用前后端代码是很有好处的。