class IEventData
{ 
};

class IEventReceiver
{
   void OnEvent(int evt, IEventData* data) = 0;
};

struct Events
{ 
    int m_event;
    std::list<IEventReceiver*> m_records;
};

class EventManager
{
    // Registers an Event. This adds a new List to m_eventList.
    void RegisterEvent(int evt);
    // Removes the Event and all listeners(receivers) from the List
    void UnregisterEvent(int evt);
    // Registers an Receiver. A receiver can be added multiple times for different events to receive more than one event.
    void RegisterReceiver(int evt, IEventReceiver* rec);
    // Unregisters the receiver for the specified event.
    void UnregisterReceiver(int evt, IEventReceiver* rec);

    // Walks thorugh our list and searches for the event. If the event was 
    // found, he calls all listed receivers and calls them. IEventData must 
    // be casted with reinterpret_cast to the type of event-data which is
    // passed, e.g. KeyDownEvtData etc.
    void Notify(int evt, IEventData* data = NULL);

    // Holds all events and their receivers in a list.
    std::list<Events> m_eventlist;
};

// from the class where the event happens:EventManager::RegisterEvent(EVT_MYEVENT);//when the event happens:MyEventData* data = new MyEventData("Hello Event");EventManager::Notfiy(EVT_MYEVENT, data);// In the class where you want to receive the event:EventManager::RegisterReceiver(EVT_MYEVENT, this);void OnEvent(int evt, IEventData* data){    switch(evt)   {    case EVT_MYEVENT:         foobar(); break;   }}

Quote:
Your design also breaks type safety by doing an upcast from IEventData to it's appropriate subclass.

type 'a eventReceiver = 'a -> unittype 'a event val add_receiver    : 'a event -> 'a eventReceiver -> unitval remove_receiver : 'a event -> 'a eventReceiver -> unitval notify          : 'a event -> 'a               -> unit

template <typename T> class IEventReceiver {public:  virtual void operator() (const T&) = 0;  typedef boost::shared_ptr< IEventReceiver<T> > shared_ptr;};template <typename T> class Event{public:  typedef typename IEventReceiver<T>::shared_ptr receiver_type; private:  struct call   {    const T &t;    call(const T& t) : t(t) {}    void operator() (const receiver_type &r) const { (*r)(t); }  };  std::vector<receiver_type> receivers;public:  void Add(const receiver_type &r)  {    receivers.push_back(r);  }  void Remove(const receiver_type &r)  {    receivers.remove(r);  }  void Notify(const T& t)   {    std::for_each(receivers.begin(),receivers.end(), call(t));  }};

// from the class where the event happens:struct EventManager{  Event<MyEventData*> myEvent;};//when the event happens:MyEventData* data = new MyEventData("Hello Event");eventManager.myEvent.Notify(data);// In the class where you want to receive the event:class MyEventReceiver : public IEventReceiver<MyEventData*>{public:   void operator()(MyEventData* data)  {      foobar();  }};eventManager.myEvent.Add(new MyEventReceiver);

Quote:
Of course you can. If you need to dispatch 5 billion events per second. Or 20. Or you're running a debug build. Or you subscribe 500,000 listeners to 500,000 events. Or you are running on 486. Or you are on embedded platform. So many situations....