Question

我一直在学习C ++并试图用我熟悉的其他语言来实现各种习语。

最近我尝试实现一个中心EventDispatcher，多个对象可以注册可以接受N个参数的事件，而对EventDispatcher :: dispatch（event_name）的单个调用将调用所有已注册的事件回调。

首先，我为Event创建了一个模板类;

template <typename ..._args>
class Event
{
public:
    //Alias for template callback
    using _callback = std::function<void(_args...)>;

    //Ctor & Dtor
    explicit Event(std::string const& name, _callback const& cb) : _name(name), _cbFunc(cb) {}
    ~Event() {}

    //Accessors
    std::string const& getName() const { return this->_name; }

    //Methods
    void trigger(_args... a) { this->_cbFunc(a...); }
private:
    //Event identifier
    std::string _name;
    //Event callback - can't be changed inside event.
    _callback const _cbFunc;
};

通过这种结构，我可以定义如下例所示的事件：

void testCallback(int a) {
    std::cout << a << std::endl;
}

Event<int> _event("TestEvent", std::bind(&testCallback, _1));
_event.trigger(20); //This will actually output 20 to the console.

我接下来要做的是，有一个EventDispatcher类，应该定义如下：

class EventDispatcher
{
public:
    EventDispatcher();
    ~EventDispatcher();

    void registerEvent(**Event of any type**);
    void dispatchEvent(std::string const& eventName, ....args);
private:
    std::map<std::string, std::vector<**Event of any type**>> _eventList;
};

这样我就可以这样打电话了;

EventDispatcher _dispatcher;
_dispatcher.registerEvent(_event); //event defined in the previous example.

_dispatcher.dispatchEvent("TestEvent", 20); //this should call event's trigger() method with arguments passed to it actually.

但是，我无法弄清楚如何实现中央调度程序并让它能够注册模板化事件实例，然后将可变数量的参数传递给dispatchEvent（...）并使其触发所有事件一个模板化事件的载体。

我如何实现这样的功能？我的思维过程是否正确或远离c ++实现这样一个系统的方式？任何提示都会受到欢迎。

Answer 1

我建议使用事件类（IEvent）的抽象基类（Event）的解决方案以及带有可变参数和dynamic_cast的模板调度程序方法。

使用抽象方法getName：

的Apstrac基类

class IEvent
{
public:
    virtual const std::string & getName() const = 0;
};

您的事件类派生自IEvent：

template <typename ..._args>
class Event : public IEvent
{
public:
    //Alias for template callback
    using _callback = std::function<void(_args...)>;

    //Ctor & Dtor
    //template< typename T_CB >
    explicit Event( const std::string & name, const _callback & cb ) : _name(name), _cbFunc(cb) {}
    ~Event() {}

    //Accessors
    virtual const std::string & getName() const override { return this->_name; }

    //Methods
    void trigger(_args... a) { this->_cbFunc(a...); }
private:
    //Event identifier
    std::string _name;
    //Event callback - can't be changed inside event.
    _callback const _cbFunc;
};

使用模板方法的调度程序：

class EventDispatcher
{
public:
    EventDispatcher() {}
    ~EventDispatcher()
    {
      for ( auto el : _eventList )
      {
        for ( auto e : el.second )
          delete e;
      }
    }

    void registerEvent( IEvent *event )
    {
      if ( event )
          _eventList[event->getName()].push_back( event );
    }

    template <typename ..._args>
    void dispatchEvent( const std::string & eventName, _args...a )
    {
      auto it_eventList = _eventList.find( eventName );
      if ( it_eventList == _eventList.end() )
        return;
      for ( auto ie : it_eventList->second )
      {
        if ( Event<_args...> * event = dynamic_cast<Event<_args...>*>( ie ) )
          event->trigger( a... );
      }
    }

private:
    std::map<std::string, std::vector<IEvent*>> _eventList;
};

最后申请：

void testCallback(int a) {
    std::cout << a << std::endl;
}

int main()
{
  EventDispatcher eventDisp;
  eventDisp.registerEvent( new Event<int>( "TestEvent", &testCallback ) );

  eventDisp.dispatchEvent( "TestEvent", 20 );

  return 0;
}

具有C ++模板化事件类型的Central Event Dispatcher

1 个答案: