C++中的事件分發

　　本文意在展現一個C++實現的通用事件分發系統，能夠靈活的處理各種事件。對於事件處理函數的注冊，希望既能注冊到普通函數，注冊到事件處理類，也能注冊到任意類的成員函數。這樣在游戲客戶端的邏輯處理中，可以非常靈活的處理事件，讓普通函數和類的成員函數既能手動調用，又能作為事件響應函數。

　　游戲是一個交互很強的軟件。在客戶端中，事件充斥於整個程序的各個角落，玩家操作事件，網絡消息事件，音頻事件，定時事件等等。這些事件通常參數不一致，分屬不同系統，使得消息的處理非常離散，分布於各個UI和系統類中。這使得在設計事件分發系統的時候，需要充分考慮通用性，能夠適應各種處理函數需求。服務器在處理網絡和數據庫消息時，雖然通常是固定的處理格式，但同樣需要實現一個統一的事件分發的機制。客戶端C#有delegate的存在，因此可以非常方便的將成員函數綁定到delegate進行調用。在unity項目中，利用C#的這一特性，非常容易搭起事件系統框架。但是，C++項目由於常常有成員函數和普通函數並存，因此事件分發時，需要考慮到兩種情況。

　　本文實現的事件分發系統是一個集中注冊和分發的系統。消息的注冊和分發都由EventManager單例負責，如果需要，可以在EventManager中加入EventQueue實現事件隊列，進而緩存消息，異步分發。以下為EventManager類實現。

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

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

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

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_(0)
    {}
    ~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 0;
    }
};

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 0;
    }
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 0;
    }
};

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指針的方式是最靈活和通用的，可以傳遞任意消息，甚至可以實現消息的嵌套，遞歸傳遞消息。在客戶端和服務器都能有一致的應用，這對於后期想共用前后端代碼是很有好處的。