Very simple events implementation
Listner needs a virtual destructor
and the OnEvent() method should probably be pure virtual:

class Listener
{
public:
    virtual void OnEvent(Event&amp; event, Dispatcher&amp; sender) {};
};

// Try

class Listener
{
    public:
        virtual ~Listener() {}
        virtual void OnEvent(Event&amp; event, Dispatcher&amp; sender) = 0;
};


You need the virtual destructor because delete will more than likely be called via a pointer to the base class (Listener) at some point.

No point in implementing OnEvent() to do nothing if you need sombody to over-ride it.

Personally I would prefer to use boost::ptr_vector&lt;&gt; rather than a std::vector&lt;std::shared_ptr&lt;&gt;&gt;. The boost vector has a couple of advantages (less lcoks required). Also its members are provided via references rather than pointers so it makes it more natural to use with the standard algorithms (not such a big deal in C++11 (with lambdas) but it makes C++03 much easier to use).

typedef std::shared_ptr&lt;Listener&gt; ListenerPtr;
typedef std::vector&lt;ListenerPtr&gt; Listeners;
Listeners _listeners;

// Replace with:

boost::ptr_vector&lt;Listener&gt;  listeners;


Be careful of using '_` on the front of identifiers. The rules are not obvious so best avoided to make sure you don't actually break them. Underscore Rules

Personally not a fan of the following:

   if( _listeners.end() != std::find(_listeners.begin(), _listeners.end(), listener) )


Nothing wrong with it. But reversing the order of the test just makes you pause a second. See Yoda Conditionals.

Prefer to use standard algorithms rather than hand coded loops.

   for( Listeners::iterator iter = _listeners.begin(); iter != _listeners.end(); ++iter )
        (*iter)-&gt;OnEvent(event, *this);

   // Try
   std::for_each(listeners.begin(), listeners.end(),
                 std::bind2nd(Listner::OnEvent, event)
                ); // Assume boost::ptr_vector&lt;&gt;

   // Or go all C++11 on us
   std::for_each(std::begin(listeners), std::end(listeners),
                 [&amp;event](std::shared_ptr&lt;Listener&gt;&amp; lis) {lis-&gt;OnEvent(event);}
                );


If you want to have listeners that only deal with a specific type of event. You can write your Listner to be a filtering lsitener.

class Listener
{
public:
    virtual void OnEvent(Event&amp; event, Dispatcher&amp; sender) {};
};


Change to:

template&lt;class ForEvent&gt;
class Listener
{
    public:
        ~Listener() {}

        // This is the method called by the dispatcher.
        void eventFilter(OnEvent&amp; event, Dispatcher&amp; sender)
        {
             // dynamic_cast to a pointer type.
             // Result is NULL if not the correct type.
             // If you used a value type then it would throw an exception.
             ForEvent* specialEvent = dynamic_cast&lt;ForEvent*&gt;(&amp;event);
             if (specialEvent != NULL)
             {
                 // Only call the OnEvent for the types we want.
                 // put back to a references (so OnEvent does not need to
                 // check for NULL).
                 this-&gt;OnEvent(*specialEvent, sender);
             }
        }

        virtual void OnEvent(ForEvent&amp; event, Dispatcher&amp; sender) = 0;
};