Re: How to detect overwritten virtual method in base class?

* macracan:


In order to land on a good solution you have to consider also dispatch
to the event handler functions, and extensibility, i.e. adding new ones.

And that general problem is quite complex.

I remember having a long discussion with Andrei Alexandrescu over in
comp.lang.c++.moderated about this. Andrei maintained that this problem
showed the need for language support for post-constructors in C++, I
maintained that it did not, but then, the concrete problem wasn't
explained until well into the debate where I'd already made my stand.
Anyways, the solution sketch below uses the idea of post-construction:

<code>
#include <cstddef>
#include <map>
#include <memory>

#include <iostream>
#include <ostream>

void say( char const s[] ) { std::cout << s << std::endl; }

namespace windowEvent
{
     struct Data { long id; Data( long x ): id( x ) {} };

     class Dispatcher
     {
     public:
         virtual void dispatch( Data const& ) = 0;
     };

     class Handler;
};

class WithFinalInit
{
template< typename T> friend
     std::auto_ptr<T> fullyInitialized( std::auto_ptr<T> );

public:
     struct Obscurity {};

     static void* operator new( std::size_t size, Obscurity const& )
     {
         return ::operator new( size );
     }

     static void operator delete( void* p, Obscurity const& )
     {
         ::operator delete( p );
     }

     virtual ~WithFinalInit() {}

private:
     virtual void doFinalInit() = 0;
};

template< typename T >
std::auto_ptr<T> fullyInitialized( std::auto_ptr<T> p )
{
     static_cast<WithFinalInit*>( p.get() )->doFinalInit();
     return p;
}

#define NEW_WINDOW( type, args ) \
     fullyInitialized( std::auto_ptr<type>( \
         new((WithFinalInit::Obscurity())) type args ) \
         )

class WindowWithEvents
     : public WithFinalInit
     , protected windowEvent::Dispatcher
{
friend class windowEvent::Handler;
friend class Window;

private:
     typedef std::map<long, windowEvent::Dispatcher*> EventMap;
     EventMap myEvents;

     void addEventHandler( long id, windowEvent::Dispatcher& handler )
     {
         say( "Adding event handler" );
         myEvents[id] = &handler;
     }

     virtual void dispatch( windowEvent::Data const& eventData )
     {
         EventMap::const_iterator const it = myEvents.find( eventData.id );
         if( it != myEvents.end() )
         {
             windowEvent::Dispatcher* const handler = it->second;
             handler->dispatch( eventData );
         }
     }

     virtual void doFinalInit()
     {
         long mask = 0;
         for(
             EventMap::const_iterator it = myEvents.begin();
             it != myEvents.end();
             ++it
             )
         {
             mask |= it->first;
         }
         say( "XSelect()" );
         //XSelectInput(/* some other params */, mask);
     }

     WindowWithEvents()
     { say( "WindowWithEvents::<init>() finished" ); }

public:
     virtual ~WindowWithEvents() {}
};

class Window: public WindowWithEvents
{
// Note: this class is necessary even without any member functions.
public:
     void testDispatch( long id ) { dispatch( id ); }
};

namespace windowEvent
{
     class Handler: public Dispatcher
     {
     protected:
         Handler( WindowWithEvents& w, long id )
         {
             w.addEventHandler( id, *this );
             say( "Handler::<init>() finished" );
         }
     };

     class Move: public Handler
     {
     protected:
         virtual void dispatch( Data const& eventData )
         {
             onMove( 123, 456 );
         }

     public:
         Move( WindowWithEvents* w ): Handler( *w, 1 )
         { say( "Move::<init>() finished" ); }

         virtual void onMove( int x, int y ) = 0;
     };

     class Draw: public Handler
     {
     protected:
         virtual void dispatch( Data const& eventData )
         {
             onDraw();
         }

     public:
         Draw( WindowWithEvents* w ): Handler( *w, 2 )
         { say( "Draw::<init>() finished" ); }

         virtual void onDraw() = 0;
     };
} // namespace windowEvent

//------------------------ Client code:

struct MyWindow
     : Window
     , windowEvent::Move
     , windowEvent::Draw
{
protected:
     virtual void onMove( int x, int y ) { say( "Moving" ); }
     virtual void onDraw() { say( "Drawing" ); }

public:
     MyWindow()
         : windowEvent::Move( this )
         , windowEvent::Draw( this )
     { say( "MyWindow::<init>() finished" ); }

     ~MyWindow() { say( "MyWindow::<destroy>()" ); }
};

int main()
{
     std::auto_ptr<MyWindow> w = NEW_WINDOW( MyWindow,() );
     w->testDispatch( 1 );
     w->testDispatch( 2 );
}
</code>

<output>
WindowWithEvents::<init>() finished
Adding event handler
Handler::<init>() finished
Move::<init>() finished
Adding event handler
Handler::<init>() finished
Draw::<init>() finished
MyWindow::<init>() finished
XSelect()
Moving
Drawing
MyWindow::<destroy>()
</output>

It's an interesting question whether this program exhibits formally
Undefined Behavior.

Disclaimer: only tested with one (old) compiler.

Cheers, and hth.,

- Alf

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?