C++ event system - using heap or stack based events

Question

I'm trying to design a simple event system that, "basically", looks like this:

• the observer entity keeps a list of all objects that need to be notified. It also stores a queue of fired events. Events are then processed by the object list, iteratint through this object list.
• an object keeps a list of observers it sends events to. Each particular object, that inherits from the base object, can fire its own specialised events (key, mouse, collision, etc.). The object also has a method HandleEvent(..) with different overloads for compile time type detection, instead of using dynamic_casting.

What would be better to choose, when firing events: creating them on the stack and passing them by reference, or allocating them dynamically on the heap and use dynamic_casting and let the observer deallocate them when they're processed by the objects that can handle them? (e.g. isn't dynamic allocation unnecessary when an event can be fired quite often; what about dynamic casting, isn't it avoidable?).

Also, this is not quite a thread-safe scenario..

Answer 1

Do you need dynamic allocation? No. Typically, you want

void fireEvent()
{
    Event ev;
    for ( each observer )
       observer.trigger(ev);
}

And the observer's signature

void trigger(const Event& ev);

Note that "passing references to them" isn't true, pedantically speaking. It's actually "passing them by reference".