class Base
{    
public:
    virtual Base* getSelf()
    {return this;}
};

class Derived1 : public Base
{
public :
    virtual Derived1* getSelf()
    {return this;};
};

class Derived2 : public Base
{    
public :
    virtual Derived2* getSelf()
    {return this;};
};

class Tester
{
public:
    virtual void Test(Derived1* Value)
    {
        ::MessageBox(NULL, _T("TEST Derived1"),_T("TEST Derived1"), MB_OK);
    }
    virtual void Test(Derived2* Value)
    {
        ::MessageBox(NULL, _T("TEST Derived2"),_T("TEST Derived2"), MB_OK);
    }    
};

...
//хочется что бы в точке использования этого хозяйства
Base* pBase1 = new Derived1;
Base* pBase2 = new Derived2;

Tester* pTester = new Tester;
pTester->Test(pBase1->getSelf());// вот здесь хочу вызов правильного Test'a а не ошибку компиляции

class Base
{    
public:
    virtual void testMe(Tester* t) = 0;
};

class Derived1 : public Base
{
public :
    virtual void testMe(Tester* t)
    { t->Test(this);}
};

class Derived2 : public Base
{    
public :
    virtual void testMe(Tester* t)
    { t->Test(this);}
};

virtual void Test(Base* Value) {...}

А>Да, в самом деле, getSelf для потомков перегружают Base::getSelf. Не знал про такую фичу

void Test(Derived1* Value)

N>>virtual void Test(Base* Value) {...}
N>>

virtual void Test(Base* Value) {assert(false);}

class Base
{    
public:
    virtual Base* getSelf()
    {return this;}
    virtual void Test() {/*общий код*/};
};
class Derived1 : public Base
{
public :
    virtual Derived1* getSelf()
    {return this;};
    virtual void Test() {/*специфика для Derived1*/}
};
class Derived2 : public Base
{
public :
    virtual Derived1* getSelf()
    {return this;};
    //а тут например, можно не писать свой Test(), будет использоваться Base::Test()
};

N>virtual void Test(Base* Value) {assert(false);}
N>

class Tester
{
public:
    virtual void Test (Base* Value)
    {
        ::MessageBox(NULL, _T("TEST0"),_T("TEST0"), MB_OK);
    }
    virtual void Test(Derived1* Value)
    {
        ::MessageBox(NULL, _T("TEST1"),_T("TEST1"), MB_OK);
    }
    virtual void Test(Derived2* Value)
    {
        ::MessageBox(NULL, _T("TEST2"),_T("TEST2"), MB_OK);
    }    
};

N>class Base
N>{    
N>public:
N>    virtual Base* getSelf()
N>    {return this;}
N>    virtual void Test() {/*общий код*/};
N>};
N>class Derived1 : public Base
N>{
N>public :
N>    virtual Derived1* getSelf()
N>    {return this;};
N>    virtual void Test() {/*специфика для Derived1*/}
N>};
N>class Derived2 : public Base
N>{
N>public :
N>    virtual Derived1* getSelf()
N>    {return this;};
N>    //а тут например, можно не писать свой Test(), будет использоваться Base::Test()
N>};
N>

class Base// сообщения
{    
public:
int SomeTypeID;
    virtual Base* getSelf()
    {return this;}
};

class Derived1 : public Base//первоее сообщение
{
public :
    virtual Derived1* getSelf()
    {return this;};
};

class Derived2 : public Base//второе
{    
public :
    virtual Derived2* getSelf()
    {return this;};
};


class Tester
{

void ProcessDerived1(Derived1* Val) {};
void ProcessDerived2(Derived2* Val) {};
...
void CommonProcessMess(void* Val)
{
Base* pBase = (Base*)Val;//точно знаем что это он
switch(pBase->SomeTypeID)
{
case TypeIDDerived1:
ProcessDerived1((Derived1 *)pBase );
break;
case TypeIDDerived2:
ProcessDerived2((Derived2 *)pBase );
break;

};
}
...
};

Хочется :

class Tester
{
ProcessDeriverd(Derived1* Val){};
ProcessDeriverd(Derived2* Val){};


void CommonProcessMess(void* Val)
{
Base* pBase = (Base*)Val;//точно знаем что это он
//и вместо switch вызываем
ProcessDeriverd(pBase->getSelf());//b получаем ошибку компилляции
};

}

_>

_>

class Base// сообщения
{    
protected :

    Base( int id ) : SomeTypeID( id ) {}

public:
    int SomeTypeID;
    virtual Base* getSelf()
    {return this;}

    virtual Base* querySelf( int type ) 
    { return NULL; }            
};

template < class Owner > 
struct QueryImpl : public Base
{
    QueryImpl( int id ) : Base( id ) {}

    virtual Base* querySelf( int type ) 
    { return (type == Owner::TYPE ? this->getSelf() : Base::querySelf(type) ); }
};

class Derived1 : public QueryImpl< Derived1 > //первое сообщение
{
    typedef QueryImpl< Derived1 > base;
public :

    static const int TYPE = 1;

    Derived1() : base( TYPE ) {}    

    virtual Derived1* getSelf()
    {return this;};    
};

class Derived2 : public QueryImpl< Derived2 > //второе
{    
    typedef QueryImpl< Derived2 > base;
public :

    static const int TYPE = 2;

    Derived2() : base( TYPE ) {}    

    virtual Derived2* getSelf()
    {return this;};
};

struct MessageProcessor 
{
    typedef boost::mpl::list< Derived1, Derived2 > messages_list;
    typedef boost::mpl::end< messages_list >::type end_iterator;
    typedef boost::mpl::begin< messages_list >::type begin_iterator;

    void processDerived( Derived1 * ) {}
    void processDerived( Derived2 * ) {}            

    template < class Iter >
    bool process( Base * base )
    {
        typedef typename boost::mpl::deref<Iter>::type message_type;

        Base * tmp = base->querySelf( message_type::TYPE );
        if ( tmp != NULL )
        {
            this->processDerived( (message_type *)tmp );
            // эквивалентно по идее такому
            // this->processDerived( (message_type *)base );

            return true;
        }

        return process< typename boost::mpl::next< Iter >::type >( base );
    }

    template <>
    bool process<end_iterator>( Base * base){ return false; }

    void commonProcess( void * arg )
    {
        Base * base = (Base *)arg;        
        if ( this->process< boost::mpl::begin< messages_list >::type >( base ) ) 
        {
            // удалось обработать сообщение
        }
        else
        {
            // не получилось обработать
        }
    }
};

void test_messages()
{
    MessageProcessor processor;

    Derived1 der1;
    Derived2 der2;
    //Base base;

    processor.commonProcess( static_cast< Base *>(&der1) );
    processor.commonProcess( static_cast< Base *>(&der2) );
    //processor.commonProcess( &base );
}

class Derived1;
class Derived2;

struct IProcessor 
{
    virtual void process( Derived1 * ) = 0;
    virtual void process( Derived2 * ) = 0;
};

class Base// сообщения
{    
protected :

    Base( int id ) : SomeTypeID( id ) {}

public:
    int SomeTypeID;
    virtual Base* getSelf()
    {return this;}        

    virtual void startProcess( IProcessor * processor ) = 0;
};

class Derived1 : public QueryImpl< Derived1 > //первое сообщение
{
public :

    static const int TYPE = 1;

    Derived1() : Base( TYPE ) {}    

    virtual Derived1* getSelf()
    {return this;};    

    virtual void startProcess( IProcessor * processor )
    {
        processor->process( this );
    }
};

class Derived2 : public Base //второе
{    
public :

    static const int TYPE = 2;

    Derived2() : Base( TYPE ) {}    

    virtual Derived2* getSelf()
    {return this;};

    virtual void startProcess( IProcessor * processor )
    {
        processor->process( this );
    }
};