class IEventData
{ 
public:
   IEventData() {};
};

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

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

class EventManager
{
public:
    // Registriert ein Event und fügt es der Liste hinzu.
    void RegisterEvent(int evt);
    // Entfernt ein Event und all seine Receiver.
    void UnregisterEvent(int evt);
    // registriert einen Receiver für ein Event. Jeder Receiver kann so viele 
    //Events registrieren wie er möchte, damit ein Interface reicht. 
    void RegisterReceiver(int evt, IEventReceiver* rec);
    // Entfernt einen Receiver für ein best. Event
    void UnregisterReceiver(int evt, IEventReceiver* rec);

    // Geht die Liste durch und sucht nach einem Event. Wenn das Event 
    // gefunden wurde, ruft er alle receiver auf (OnEvent) und gibt die
    // event-daten weiter, die mit reinterpret_cast auf den jeweiligen typ
    // gecastet werden müssen, wie als bsp KeyDownEventData.
    void Notify(int evt, IEventData* data = NULL);

    // Hält alle Events und deren Receiver in einer liste.
    std::list<Events> m_eventlist;
};

Was haltet Ihr so davon? Könnte das zu Problemen in der performance führen mit den Listen? Was wäre der Gegenvorschlag? Das Ding muss halt schon performant sein, damit die Calls schnell ausgeführt werden können. Eine Instanz dieses Managers wird über einen Getter in einer anderen Klasse "global" zur Verfügung gestellt.
lg

Ich würde als erste Änderung Queues benutzen welche die Events speichern, so dass das Erzeugen eines Events in O(1) liegt, und dann von Zeit zu Zeit die Events abarbeiten.
Falls man wirklich einmal ein Event hat das sofort versandt werden soll, dann würde ich das so wie ein EventManager handhaben, also einmal kurz alle Receiver durchgehen und die benachrichtigen (da wäre zu überlegen ob man in solch einer Schleife dann das sofortige Benachrichtigen deaktiviert damit das nicht passiert was ich weiter unten geschrieben habe).

Übrigens wenn deine Receiver selber Events versenden, dann wird das ganze recht undurchsichtig.

Könnte das zu Problemen in der performance führen mit den Listen?

Ja, die std::list<Events> m_eventlist wird wohl bremsen wenn mal viele Events registriert sind, weil du die von Anfang bis Ende durchsuchen musst (bis du den passenden Eintrag gefunden hast, was für den letzten Eintrag dann recht lange dauern kann).

Was wäre der Gegenvorschlag?

std::map verwenden.

// z.b.
std::map<int, std::set<IEventReceiver*> > m_blubb;
// oder gleich
std::map<int, std::set<boost::shared_ptr<boost::function<void()> > > > m_blubb;

Könnte das zu Problemen in der performance führen mit den Listen?

Ja, die std::list<Events> m_eventlist wird wohl bremsen wenn mal viele Events registriert sind, weil du die von Anfang bis Ende durchsuchen musst (bis du den passenden Eintrag gefunden hast, was für den letzten Eintrag dann recht lange dauern kann).

Was wäre der Gegenvorschlag?

std::map verwenden.

// z.b.
std::map<int, std::set<IEventReceiver*> > m_blubb;
// oder gleich
std::map<int, std::set<boost::shared_ptr<boost::function<void()> > > > m_blubb;

Zuerst einmal sollte man herausfinden wie viele Receiver es im Normalfall geben wird, denn bei nur wenigen ist die Liste schneller.