Re: Misuses of RTTI

szymon.gatner@gmail.com (bravo) wrote (abridged):


I wouldn't be comfortable with it, partly for performance reasons. Also
partly because you might actually want to send a NukeExplosionEvent and
have it treated as an ExplosionEvent by clients that didn't know about it.
I actually prefer the dynamic_cast version, at least when the number of
different types is small.

One alternative would be some kind of double-dispatch. The article
mentions this in the PS, and says that it leads to cyclic dependencies,
but these can be broken by using an abstract class. This leads to the
classic Visitor used for type discovery.

Another, possibly better approach is to simply never lose track of the
types in the first place. Instead of sending all events to a single
onEvent function, have a different function for each event.

     template <typename Event>
     class Handler {
     public:
         virtual void onEvent( const Event *pEvent ) = 0;
     };

     template <typename Event>
     class Handlers {
         typedef std::vector< Handler<Event> * > Handlers;
         Handlers handlers;
     public:
         void addHandler( Handler<Event> *pHandler ) {
             handlers.push_back( pHandler );
         };

         void onEvent( const Event *pEvent ) {
             for (Handlers::iterator i = handles.begin(); i !=
                     handlers.end(); ++i)
                 (*i)->onEvent( pEvent );
         }
     }

     struct ExplosionEvent;
     struct EnemyHitEvent;

     class EventSource {
         Handlers<ExplosionEvent> explosionHandlers;
         Handlers<EnemyHitEvent> enemyHitHandlers;
     public:
         void addExplosionHandler( Handler<ExplosionEvent> *pHandler ) {
             explosionHandlers.addHandler( pHandler );
         };

         void onEvent( const ExplosionEvent *pEvent ) {
             explosionHandlers.onEvent( pEvent );
         }
         // Repeat for EnemyHit.

     };

     class SomeHandler :
             Handler<ExplosionEvent>, Handler<EnemyHitEvent> {
     public:
         virtual void onExplosion( const ExplosionEvent *pEvent );
         virtual void onEnemyHit( const EnemyHitEvent *pEvent );

         void listenTo( EventSource *pSource ) {
             pSource->addExplosionHandler( this );
             pSource->addEnemyHitHandler( this );
         }
     };

The EventSource keeps a separate Handlers<Event> for each type of event.
That way we never mix handlers for different events together, so we never
need RTTI to disentangle them. This achieves event dispatching with a
single virtual function and no casts.

These handler classes need to inherit from Handler<Event>. You can avoid
that by using the MemberFunctionHandler approach in the original article,
at a slight cost in memory and dispatching time. The article uses a
static_cast, which you can eliminate by making EventT a template
parameter of the base class.

-- Dave Harris, Nottingham, UK.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]