CS>namespace html
CS>{
CS>  struct element
CS>  {
CS>    ... data ...
CS>    void do_layout() = 0;
CS>  };

CS>  struct paragraph : public element
CS>  {
CS>    void do_layout()  { layout as a text container };
CS>  };

CS>  struct div : public element
CS>  {
CS>    void do_layout()  { layout as a block container };
CS>  };
CS>}
CS>

namespace html
{
    struct paragraph;
    struct div;

    struct element_visitor
    {
        virtual void do_layout(paragraph&) = 0;
        virtual void do_layout(div&) = 0;
    };

    struct element
    {
        int data;
        virtual void do_layout(element_visitor&) = 0;
    };

    struct paragraph : element
    {
        virtual void do_layout(element_visitor& e)  {e.do_layout(*this);};
    };

    struct div : element
    {
        virtual void do_layout(element_visitor& e)  {e.do_layout(*this);};
    };

    struct block_inside_visitor : element_visitor
    {
        virtual void do_layout(paragraph& e)
        {
            std::cout << "block_inside: paragraph " << e.data << std::endl;
        }

        virtual void do_layout(div& e)
        {
            std::cout << "block_inside: div " << e.data << std::endl;
        }
    };

    struct inline_inside_visitor : element_visitor
    {
        virtual void do_layout(paragraph& e)
        {
            std::cout << "inline_inside: paragraph " << e.data << std::endl;
        }

        virtual void do_layout(div& e)
        {
            std::cout << "inline_inside: div " << e.data << std::endl;
        }
    };
}

int main()
{
    html::paragraph p; p.data = 1;
    html::div d; d.data = 2;

    html::element& e1 = p;
    html::element& e2 = d;

    html::block_inside_visitor v1;
    e1.do_layout(v1);
    e2.do_layout(v1);

    html::inline_inside_visitor v2;
    e1.do_layout(v2);
    e2.do_layout(v2);

    // dynamic switch
    html::element_visitor* v = 0;
    if (rand())
        v = &v1;
    else
        v = &v2;
    e1.do_layout(*v);
    e2.do_layout(*v);
}

struct data
{
    int i;
};

struct base
{
    virtual void draw() = 0;
};

struct impl1 : base, virtual data
{
    virtual void draw()
    {
        std::cout << "impl1 " << i << std::endl;
    }
};

struct impl2 : base, virtual  data
{
    virtual void draw()
    {
        std::cout << "impl2 " << i << std::endl;
    }
};

struct last : impl1, impl2
{
    last() : self(static_cast<impl1*>(this)) {}

    template<typename type>
    void switch_to()
    {
        self = static_cast<type*>(this);
    }

    template<void (base::*f)()>
    void exec()
    {
        (self->*f)();
    }

    base* self;
};


int main()
{
    last l;
    l.exec<&base::draw>();
    l.switch_to<impl2>();
    l.exec<&base::draw>();
}

R>

/* main.cpp */ 

#include <stdio.h>

#include <new>

/* -------------- */ 

template <bool Cond,class T> struct EnableIf;
 
template <class T> struct EnableIf<true,T> { typedef T Ret; };
 
template <class T> struct EnableIf<false,T> {};
 
/* -------------- */ 

struct D
 {
  int data;
  
  D() : data(0) { printf("D::D()\n"); }
 };
 
class P : protected D
 {
  public:
  
   P() : D() { printf("P::P()\n"); }
   
   virtual ~P() { printf("P::~P() : data=%d\n",data); }
   
   explicit P(D *from) : D(*from) { printf("P::P(D *) : data=%d\n",data); }
   
   void saveTo(D *to) { *to=*this; }
   
   virtual void fun()=0;
   
   template <class T> struct Enable;
   
   template <class T>
   typename Enable<T>::Ret // instead of P *
   mutate()
    {
     P *ret=this;
     D temp;
     
     saveTo(&temp);
     
     ret->~P();
     
     new(ret) T(&temp);
     
     return ret;
    }
 }; 
 
template <class T> struct P::Enable : public EnableIf<(sizeof (T)==sizeof (P)),P *> {};
   
class A : public P
 {
  public:
  
   A() : P() { printf("A::A()\n"); }
   
   A(::D *from) : P(from) { printf("A::A(D *) : data=%d\n",data); }
   
   ~A() { printf("A::~A()\n"); }
   
   virtual void fun() { data++; }
 }; 
 
class B : public P
 {
  public:
  
   B() : P() { printf("B::B()\n"); }
   
   B(::D *from) : P(from) { printf("B::B(D *)\n"); }
   
   ~B() { printf("B::~B()\n"); }
   
   virtual void fun() { data--; }
 }; 
 
/* main() */   

int main()
 {
  P *p=new A();
  
  p->fun();
  p->fun();
  
  p=p->mutate<B>();
  
  p->fun();
  
  delete p;
  
  return 0;
 }

#if defined(__cplusplus) && !defined(CINTERFACE)
    IXMLElement : public IDispatch
    {
    public:
        virtual HRESULT STDMETHODCALLTYPE get_tagName( BSTR *p) = 0;
    // ...
    };
    
#else     /* C style interface */

    typedef struct IXMLElement2Vtbl
    {
        BEGIN_INTERFACE
        /* IUnknown + IDispatch vtbl skipped*/
        

        HRESULT ( STDMETHODCALLTYPE *get_tagName )( IXMLElement2 * This, BSTR *p);
        
        /* ... */
        
        END_INTERFACE
    } IXMLElement2Vtbl;

    interface IXMLElement2
    {
        CONST_VTBL struct IXMLElement2Vtbl *lpVtbl;
    };
#endif

template<class T> P* CreateHackedObject()
{
    void * buffer = new char[sizeof T];
    return new( buffer ) T;
}

void DeleteHackedObject( P* p )
{
    if( p == 0 )
        return;
    p->~P();
    delete [] static_cast<char*>( (void*)p );
}

template<class TFrom, class TTo> void SwitchTo( P* p )
{
    static_assert( sizeof( TFrom ) >= sizeof( TTo ) );
    assert( dynamic_cast<TFrom*>( p ) != 0 );
    p->~P();
    new( p ) TTo;
    assert( dynamic_cast<TTo*>( p ) != 0 );
}

template<class TFrom, class TTo> void UnsafeSwitchTo( P* p )
{
    static_assert( sizeof( TFrom ) == sizeof( TTo ) );
    assert( dynamic_cast<TFrom*>( p ) != 0 );
    {
        TTo tmp;
        memcpy( p, &tmp, sizeof( tmp ) );
    }
    assert( dynamic_cast<TTo*>( p ) != 0 );
}

struct base
{
    int i;
    virtual void draw() = 0;
};

struct d1 : base
{
    virtual void draw()
    {
        std::cout << "d1 " << i << std::endl;
    }

    static d1 instance;
};

struct d2 : base
{
    virtual void draw()
    {
        std::cout << "d2 " << i << std::endl;
    }

    static d2 instance;
};

d1 d1::instance;
d2 d2::instance;

int main()
{
    d1 d;
    base& b = d;
    b.draw();
    *reinterpret_cast<void**>(&b) = *reinterpret_cast<void**>(&d2::instance);
    b.draw();
}

class Persone {
public:
    Persone( std::string name_, std::string family_ ) : name( name_ ), family( family_ ) {}
    
    std::string GetName() const { return name; }
    std::string GetFamily() const { return family; }
    std::string GetFullName() const { return name + " " + family; }
    std::string GetInitials() const { toInitials( name ) + toInitials( family ); }

private:
    const std::string name;
    const std::string family;
    static std::string toInitials( const std::string& ); // где-то реализовано
};

void Persone* readPersone()
{
    std::string name = readPersonalStirng();
    std::string family = readPersonalStirng();
    return new Persone( name, family );
}
void ForgetPersone( Persone* p )
{
    delete p;
}
void output( Persone* p )
{
    cout << p->GetFullName();
}

// old version 1 (We are in the Europe)
namespace InEurope {
class Persone {
public:
    Persone( std::string name_, std::string family_ ) : name( name_ ), family( family_ ) {}
    
    std::string GetName() const { return name; }
    std::string GetFamily() const { return family; }
    std::string GetFullName() const { return name + " " + family; }
    std::string GetInitials() const { toInitials( name ) + toInitials( family ); }

private:
    const std::string name;
    const std::string family;
    static std::string toInitials( const std::string& ); // где-то реализовано
};
}   //  namespace InEurope

// old version 2 (We are in the Japan)
namespace InJapan {
class Persone {
public:
    Persone( std::string name_, std::string family_ ) : name( name_ ), family( family_ ) {}
    
    std::string GetName() const { return name; }
    std::string GetFamily() const { return family; }
    std::string GetFullName() const { return family + " " + name; }
    std::string GetInitials() const { toInitials( family ) + toInitials( name ); }

private:
    const std::string name;
    const std::string family;
    static std::string toInitials( const std::string& ); // где-то реализовано
};
}   //  namespace InJapan

typedef InEurope::Persone Persone;

template<typename TSeed>
class TypeIdManager {
public:
    typedef int Id_t;
    static template<typename T> Id_t Get() { return CTypeId<T>::Id; }
    static int CurIdCount() { return seed_accessor::CurIdCount(); }

private:
    static int seed;
    struct seed_accessor;    
    friend seed_accessor;
    struct seed_accessor; {
        static int NextId() { return ++TypeIdManager::seed; }
        static int CurIdCount() { return 1 + TypeIdManager::seed; }
    };
    template<typename T> struct CTypeId : seed_accessor { static const int Id = NextId(); }

    TypeIdManager(); TypeIdManager( const TypeIdManager& ); ~TypeIdManager(); // тел нет
    
};

template<typename TSeed> int TypeIdManager::seed = 0;


class ProcessorsCollection {
public:
    
    template<typename I> void Set( I* data ) { body[getId<I>()] = data; }
    template<typename I> void Get( I*& dst ) const { dst = static_cast<I*>( body[getId<I>()] ); }

    bool IsValid() const { return is_compleet(); }

private:
    mutable std::vector<void*> body;

    bool is_compleet() const
    {
        assert( body.size() <= TypeIdManager<ProcessorsCollection>::CurIdCount() );
        if( body.size() != TypeIdManager<ProcessorsCollection>::CurIdCount() )
            return false;
        for( int i = 0; i < TypeIdManager<ProcessorsCollection>::CurIdCount(); i++ )
            if( body[i] == 0 )
                return false;
        return true;
    }
    int regId( int id ) const
    {
        if( id >= body.size() )
             body.set_size( TypeIdManager<ProcessorsCollection>::CurIdCount() );
        assert( 0 <= id && id < body.size() );
        return id;
    }
    
    template<typename T> int getId() const
    {
        return regId( TypeIdManager<ProcessorsCollection>::Get<T>() - 1 );
    }
};

template<typename I, typename TProcessor>
class CProcessorRegistrar {
public:
    CProcessorRegistrar( ProcessorsCollection& storage_ ) : storage( storage_ )
    { 
        assert( getProcessor() == 0 );
        setProcessor( &theProcessor );
    }
    ~CProcessorRegistrar() 
    { 
        assert( getProcessor() == &theProcessor );
        setProcessor( 0 );
    }
    
private:
    ProcessorsCollection& storage;
    TProcessor theProcessor;

    I* getProcessor() const 
    { 
        I* tmp;
        storage.Get( tmp );
        return tmp;
    }
    void setProcessor( I* i ) { storage.Set( i ); }

    CProcessorRegistrar( const CProcessorRegistrar& ); void operator = ( const CProcessorRegistrar& ); // тел нет
};

namespace UseProcessors {
extern const ProcessorsCollection& TheDefaultProcessors;
template<class TProcessor> class ProcHolder {
public:
    ProcHolder() { SwitchTo( TheDefaultProcessors ); }
    TProcessor* operator->() const { return proc; }
    void SwitchTo( const ProcessorsCollection& implementation )
    {
        implementation.Get( proc );
        assert( proc != 0 );
    }
private:
    mutable TProcessor* proc;
};
}   //  namespace UseProcessors

//------------------------------
// Вариант с просессорами
//-----------------------------

namespace UseProcessors {
class Persone {
public:
    Persone( std::string name_, std::string family_ ) : name( name_ ), family( family_ ) {}
    
    std::string GetName() const { return name; }
    std::string GetFamily() const { return family; }
    std::string GetFullName() const { return proc->GetFullName( this ); } //2
    std::string GetInitials() const { proc->GetInitials( this ); } //2

    struct IProcessor { //2
        std::string GetFullName( const Persone* theObj ) const = 0
        std::string GetInitials( const Persone* theObj ) const = 0
    };

private:
    ProcHolder<IProcessor> proc; //2
    
    const std::string name;
    const std::string family;
public: // для процессоров //2
    static std::string toInitials( const std::string& ); // где-то реализовано
};

// Реализация версий (какой-то cpp наверное):
extern ProcessorsCollection InEurope;
class PersoneProcessorInEurope : public Persone::IProcessor {
    virtual std::string GetFullName( const Persone* theObj ) const { return theObj->Family() + " " + theObj->Name(); }
    virtual std::string GetInitials( const Persone* theObj ) const 
       { theObj->toInitials( theObj->Family() ) + theObj->toInitials( theObj->Name() ); }
};
static const CProcessorRegistrar<Persone::IProcessor, PersoneProcessorInEurope> personeInEurope( InEurope );

extern ProcessorsCollection InJapan;
class PersoneProcessorInJapan : public Persone::IProcessor {
    virtual std::string GetFullName( const Persone* theObj ) const { return theObj->Family() + " " + theObj->Name(); }
    virtual std::string GetInitials( const Persone* theObj ) const 
       { theObj->toInitials( theObj->Family() ) + theObj->toInitials( theObj->Name() ); }
};
static const CProcessorRegistrar<Persone::IProcessor, PersoneProcessorInJapan> personeInJapan( InJapan );

extern const ProcessorsCollection& TheDefaultProcessors = InEurope;


}   //  namespace UseProcessors

void Persone* readPersone()
{
    std::string name = readPersonalStirng();
    std::string family = readPersonalStirng();
    return new Persone( name, family );
}
void ForgetPersone( Persone* p )
{
    delete p;
}
void output( Persone* p )
{
    cout << p->GetFullName();
}

//---------------------------------
//  Внимание!!! Злобный хак!!! Наследников ISwitchableDT нельзя создавать где-либо кроме кучи!!!
//---------------------------------
class ISwitchableDT {
public:
    template<typename T> static T* New() 
        { return new( ::operator new( sizeof( T ) ) ) T; }
    template<typename T, typename T1> static T* New( T1 a1 ) 
        { return new( ::operator new( sizeof( T ) ) ) T( a1 ); }
    template<typename T, typename T1, typename T2> static T* New( T1 a1, T2 a2 ) 
        { return new( ::operator new( sizeof( T ) ) ) T( a1, a2 ); }
    template<typename T, typename T1, typename T2, typename T3> static T* New( T1 a1, T2 a2, T3 a3 ) 
        { return new( ::operator new( sizeof( T ) ) ) T( a1, a2, a3 ); }
    // и т. д.
    template<typename T> static void Delete( T* obj )
    {
        if( obj == 0 )
            return;
        obj->~T();
        ::operator delete( obj );
    }


protected:
    virtula ISwitchableDT() = 0 {}
    virtual SwitchToMyDT( ISwitchableDT* dst ) = 0;

    template<typename TBase> void static SwitchToImplementation( const ProcessorsCollection& patterns, TBase* obj )
    {
        TBase* pattern = 0;
        patterns.Get( pattern );
        assert( pattern != 0 );
        static_cast<ISwitchableDT*>( pattern )->SwitchToMyDT( obj );
    }
    
    template<typename TTo, typename TBase> static void SwitchToImplementation( TBase* obj )
    {
        static_assert( sizeof( *obj ) == sizeof( TTo ) );
        if( obj == 0 )
            return;
        TBase tmp;
        std::swap( *obj, tmp );
        obj->~TBase();
        new( obj ) TTo;
        std::swap( *obj, tmp );
        assert( dynamic_cast<TTo*>( obj ) == obj ); 
    } 

private:
    void* operator new( size_t ); void operator delete( void* ); // нет тел, пользуйтесь ISwitchableDT::New/Delete
    void* operator new( size_t, void* buffer ) { return buffer; }
    
};

template< class TImplementation, class TBase >
class CSwitchebleDT : public TBase {
    virtual SwitchToMyDT( ISwitchableDT* dst_ )
    {
        TBase* dst = dynamic_cast<TBase*>( dst_ );
        assert( dst != 0 );
        ISwitchableDT::SwitchToImplementation<TImplementation>( dst );
    }
};

//------------------------------
// Вариант с "переключаемыми" типами
//-----------------------------
namespace UseSwitchableDT {
class Persone : public ISwitchableDT { //1
protected: //1
    Persone() {} //1
    Persone( std::string name_, std::string family_ ) : name( name_ ), family( family_ ) {}
    
public: //1
    static Persone* New()  //1
        { return ISwitchable::New<Persone>(); }
    static Persone New( std::string name_, std::string family_ )  //1
        { return return ISwitchable::New<Persone>( name_, family_ ); }
    void SwitchTo( const ProcessorsCollection& patterns )  //1
    {
        ISwitchableDT::SwitchToImplementation( patterns, this );
        // name.SwitchTo( patterns );  // Полю тоже может быть надо
        // family.SwitchTo( patterns );   // Полю тоже может быть надо
    }
 
    std::string GetName() const { return name; }
    std::string GetFamily() const { return family; }
    virtual std::string GetFullName() const = 0; //1
    virtual std::string GetInitials() const = 0; //1

protected:
    /*const */std::string name; //1
    /*const */std::string family; //1
    static std::string toInitials( const std::string& ); // где-то реализовано
};

// Реализация версий (какой-то cpp наверное):
extern ProcessorsCollection InEurope;

class PersoneInEurope : public CSwitchebleDT< PersoneInEurope, Persone > {
    virtual std::string GetFullName() const { return name + " " + family; }
    virtual std::string GetInitials() const { toInitials( name ) + toInitials( family ); }
};
static const CProcessorRegistrar<Persone, PersoneInEurope> personeInEurope( InEurope );

extern ProcessorsCollection InJapan;

class PersoneInJapan : public CSwitchebleDT< PersoneInJapan, Persone > {
    virtual std::string GetFullName() const { return family + " " + name; }
    virtual std::string GetInitials() const { toInitials( family ) + toInitials( name ); }
};
static const CProcessorRegistrar<Persone, PersoneInJapan> personeInJapan( InJapan );


}   //  namespace UseSwitchableDT

void Persone* readPersone()
{
    std::string name = readPersonalStirng();
    std::string family = readPersonalStirng();
    return Persone::New( name, family ); //1
}
void ForgetPersone( Persone* p )
{
    Persone::Delete( p ); //1
}
void output( Persone* p )
{
    cout << p->GetFullName();
}

class P
{
   int data;
   virtual foo() = 0;
}

class A: public P
{
   // no class specific data, only methods
   virtual foo() { ++data; }
}

class B: public P
{
   // no class specific data, only methods
   virtual foo() { --data; }
}

P* p = new A;

CS>class P
CS>{
CS>   int data;
CS>   virtual foo() = 0;
CS>}

CS>class A: public P
CS>{
CS>   // no class specific data, only methods
CS>   virtual foo() { ++data; }
CS>}

CS>class B: public P
CS>{
CS>   // no class specific data, only methods
CS>   virtual foo() { --data; }
CS>}
CS>

CS>P* p = new A;
CS>

P* p = new B;

P* p = new A;
new(p) B;

CS>P* p = new A;
CS>new(p) B;
CS>

P* f(bool need_a)
{
 static A a;
 static B b;

 return need_a ? &a : &b;
}

CS>P* p = new A;
CS>new(p) B;
CS>

P* p = new A;
//Do something
p = new B(*p);

#include "new.h"

struct P
{
   int data;
   P() {}
   virtual ~P() {}
   virtual foo() = 0;
};

template <typename T>
  inline P* ctor(int d) { P* t = new T; t->data = d; return t; }
template <typename T>
  inline void turn_to(P* p) { ::new(p) T; }

struct A: public P
{
   // no class specific data, only methods
   virtual foo() { ++data; }
};

struct B: public P
{
   // no class specific data, only methods
   virtual foo() { --data; }
};

int main(int argc, char* argv[])
{
  P *p = ctor<A>(0);
  p->data = 0;
  p->foo();
    printf("step 1, p.data = %d\n", p->data);
  turn_to<B>(p);
  p->foo();
  printf("step 2, p.data = %d\n", p->data);
    return 0;
}

class Implementation
{
     virtual void f() = 0;
}

struct P
{
   int data;
   P() {}

   void SetImpl( Implementation* impl );

   virtual ~P() {}
   virtual foo() = 0;
};

КЛ>class Implementation
КЛ>{
КЛ>     virtual void f() = 0;
КЛ>}

КЛ>struct P
КЛ>{
КЛ>   int data;
КЛ>   P() {}

КЛ>   void SetImpl( Implementation* impl );

КЛ>   virtual ~P() {}
КЛ>   virtual foo() = 0;
КЛ>};


КЛ>

class Implementation
{
   virtual void f(P* p) {...}
}

struct P
{
   Implementation* pimpl;
   int data;

   P() {}
   void SetImpl( Implementation* impl ) { pimpl = impl; }

   ~P() {}
   void foo() { pimpl->foo(this); };
};

__>P* f(bool need_a)
__>{
__> static A a;
__> static B b;

__> return need_a ? &a : &b;
__>}
__>

namespace html
{
  struct element
  {
    ... data ...
    void do_layout() = 0;
  };

  struct paragraph : public element
  {
    void do_layout()  { layout as a text container };
  };

  struct div : public element
  {
    void do_layout()  { layout as a block container };
  };
}

E>template<class T> P* CreateHackedObject()
E>{
E>    void * buffer = new char[sizeof T];
E>    return new( buffer ) T;
E>}
E>

template<class T>
struct aligned_union
{
    union type
    {
        typename boost::type_with_alignment<boost::alignment_of<T>::value>::type aligner;
        char char_arr[sizeof(T)];
    };
};

...
void *buffer=(new aligned_union())->char_arr;
...

class CMyItemData;
class IMyItemProcessor {
public:
    virtual ~IMyItemProcessor();
    virtual void Method1( CMyItemData& ) = 0;
    virtual void Method2( CMyItemData& ) = 0;
    virtual void Method3( CMyItemData& ) = 0;
};

class CMyItem {
public:
    CMyItem( IMyItemProcessor*, const CMyItemData& );
    void Method1() { processor->Method1( data ); }
    void Method2() { processor->Method2( data ); }
    void Method3() { processor->Method3( data ); }

    SetProcessor( IMyItemProcessor* );

private:
    IMyItemProcessor* processor;
    CMyItemData data;

};

   
Ш>   template <class T>
Ш>   typename Enable<T>::Ret // instead of P *
Ш>   mutate()
Ш>    {
Ш>     P *ret=this;
Ш>     D temp;
Ш>     saveTo(&temp);
Ш>     ret->>~P();
Ш>     new(ret) T(&temp);
Ш>     return ret;
Ш>    }
Ш> }; 
 
Интересно, и это близко к тому что я написал.

Единственно я бы тогда уже сделал так:

[ccode]
struct P
{
template <typename T>
  void mutate()
{
   static_assert( sizeof(T) == sizeof(*this) );
   T temp;
   swap(temp);
   this->~P();
   new(this) T;
   temp.swap(*this);
}
};

swap(temp); 
temp.swap(*this);

CS>>struct P
CS>>{
CS>>template <typename T>
CS>>  void mutate()
CS>>{
CS>>   static_assert( sizeof(T) == sizeof(*this) );
CS>>   T temp;
CS>>   swap(temp);
CS>>   this->>~P();
CS>>   new(this) T;
CS>>   temp.swap(*this);
CS>>}
CS>>};
CS>>

mutate()
   {
     P *ret=this;
     D temp;
     saveTo(&temp); // swap with temp, *this is an "empty" thing now.
     ret->>~P();    // destroy this, already empty thing, harmless
     new(ret) T(&temp); // shall do swap from temp.
     return ret;
   } // dtor of temp, it should be empty at this moment

R>int main()
R>{
R>    html::paragraph p; p.data = 1;
R>    html::div d; d.data = 2;

R>    html::element& e1 = p;
R>    html::element& e2 = d;

R>    html::block_inside_visitor v1;
R>    e1.do_layout(v1);
R>    e2.do_layout(v1);

R>    html::inline_inside_visitor v2;
R>    e1.do_layout(v2);
R>    e2.do_layout(v2);

R>    // dynamic switch
R>    html::element_visitor* v = 0;
R>    if (rand())
R>        v = &v1;
R>    else
R>        v = &v2;
R>    e1.do_layout(*v);
R>    e2.do_layout(*v);
R>}
R>

template <typename T>
  void mutate(P& obj)
{
   static_assert( sizeof(T) == sizeof(obj) );
   T temp;
   obj.swap(temp);
   obj.~P();
   new(&obj) T;
   temp.swap(obj);
}

struct data
{
    int i;
};

struct base
{
    virtual void draw() = 0;
};

struct impl1 : base, virtual data
{
    virtual void draw()
    {
        std::cout << "impl1 " << i << std::endl;
    }
};

struct impl2 : base, virtual  data
{
    virtual void draw()
    {
        std::cout << "impl2 " << i << std::endl;
    }
};

struct last : impl1, impl2
{
};

int main()
{
    last l;
    base& b1 = static_cast<impl1&>(l);
    b1.draw();
    base& b2 = static_cast<impl2&>(l);
    b2.draw();
}

  base* pb = ... ; 
  pb->draw();

(self->*f)();

CS>  base* pb = ... ; 
  pb->>draw();
CS>

// Было примерно так (схема упрощённая, так как у Base может быть много наследников...
// Ко всем классам, которые надо изменить припишу слово Old
class OldBase {
public:
    virtual void Method1() = 0; // На самом деле тут есть два варианта Impl1 и Impl2

protected:
    BaseData data;
};

class OldImpl1 : public OldBase {
public:
    virtual void Method1() { data.Impl1(); }
}; 

class OldImpl2 : public OldBase {
public:
    virtual void Method1() { data.Impl2(); }
}; 

void foo( OldBase* obj )
{
    obj->Method1();
}

// а станет так

struct IBaseProcessor {
    virtual void Method( BaseData& ) = 0;
};

class CBase {
public:
    
    void Method1() { processor->Method( data ); }

protected:
    IBaseProcessor* processor;
    BaseData data;
};

struct CBasePocessorImpl1 : IBaseProcessor {
    virtual void Method( BaseData& data ) { data.Impl1(); }
};

struct CBasePocessorImpl2 : IBaseProcessor {
    virtual void Method( BaseData& data ) { data.Impl2(); }
};

foo( Base * base )
{
    base->Method1(); // вообще ничего не меняется!!!
}

    last l;
    base& b1 = static_cast<impl1&>(l);
    base& b2 = static_cast<impl2&>(static_cast<last&>((b1));

E>Всё равно отсанется необходимость в ручном поддержании "эквивалентности" различных реализаций

class P 
{
  virtual int foo() = 0;
}

class A 
{
  virtual int foo() { ... 1 }
}

class B 
{
  virtual int foo() { ... 2 }
}

class P
{
   int data;
   virtual foo() = 0;
}

class A: public P
{
   // no class specific data, only methods
   virtual foo() { ++data; }
}

class B: public P
{
   // no class specific data, only methods
   virtual foo() { --data; }
}

struct i1 {
   virtual void method1() = 0;
};

struct i2 {
   virtual void method2() = 0;
};

class p : public i1, public i2 {
private:
   myData data;
};

new(p) B;

E>Ну а в случае множественного наследования в базе вообще всё плохо будет

template<class T> P* CreateHackedObject()
{
    void * buffer = new char[sizeof T];
    return new( buffer ) T;
}

void DeleteHackedObject( P* p )
{
    if( p == 0 )
        return;
    p->~P();
    delete [] static_cast<char*>( (void*)p );
}

template<class TFrom, class TTo> void SwitchTo( P* p )
{
    static_assert( sizeof( TFrom ) >= sizeof( TTo ) );
    assert( dynamic_cast<TFrom*>( p ) != 0 );
    p->~P();
    new( p ) TTo;
    assert( dynamic_cast<TTo*>( p ) != 0 );
}

struct A { std::string text; };
struct B { std::string text; };

A* a = new A; // зовутся конструкторы полей A, в том числе и для A::text зовётся конструктор std::string
a->text = "text A";
B* b = new( a ) B; // Тут на месте a->text зовётся конструктор B::text, то есть опять таки std::string. 
// Старое тело скорее всего теряется
b->text = "text B";
delete b; // Всё нормально пока, правда ~A так никогда и не был позван :(

template<class TTo, class P> void SwitchTo( P* p )
{
    static_assert( sizeof( P ) == sizeof( TTo ) );
    P tmp;
    std::swap( *p, tmp );
    p->~P();
    new( p ) TTo;
    std::swap( *p, tmp );
    assert( dynamic_cast<TTo*>( p ) != 0 );
}

P* p = new A;
static_cast<A*>( p )->~A();
new( p ) B;
delete static_cast<B*>( p );

template<class T> P* CreateHackedObject()
{
    void * buffer = ::operator new ( sizeof T );
    return new( buffer ) T;
}

void DeleteHackedObject( P* p )
{
    if( p == 0 )
        return;
    p->~P();
    ::operator delete( p );
}

#include <iostream>
using namespace std;

class Base
{
public:
    Base()
    {
    }

    virtual ~Base()
    {}

public:
    // methods to override
    virtual void foo() = 0;
    virtual void doo() = 0;
};

struct Bar
    : Base
{
    void foo()
    {
        cout << "Bar::foo\n";
    }

    void doo()
    {
        cout << "Bar::doo\n";
    }
};

struct Baz
    : Base
{
    void foo()
    {
        cout << "Baz::foo\n";
    }

    void doo()
    {
        cout << "Baz::doo\n";
    }
};

void cast_spell( Base * from, Base * to )
{
    struct VtblHolder
    {
        void * vtbl;
    };

    VtblHolder * vtbl_holder_1 = reinterpret_cast<VtblHolder *>( from );
    VtblHolder * vtbl_holder_2 = reinterpret_cast<VtblHolder *>( to );

    vtbl_holder_1->vtbl = vtbl_holder_2->vtbl;
}

void black_magic_test()
{
    Base * pbar = new Bar();
    Base * pbaz = new Baz();

    cast_spell( pbar, pbaz );

    pbar->foo();
    pbar->doo();

    delete pbar, pbaz;
}

int main( int argc, char * argv[] )
{
    black_magic_test();
    return 0;
}

turn_to(object* p, typename TO)
{
  TO t; 
  p->transfer_data_to(t); // aka directional swap()
  new(p) TO;
  t.transfer_data_to(*p); // aka directional swap()
}

turn_to(object* p, typename TO)
{
  static TO t;
  p->_pvtbl = t._pvtbl;
}