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;
};

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 );
}

КЛ>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 };
  };
}