А>  template <class T> changeIntfRealization() {
А>    // возможные проверки на происхождение T от Interface на манер: static_assert(is_base_of<Interface, T>::value, "Ouch");
А>    new (&intf)T(); // происходит подмена VPTR
А>  }  
А>

template<typename IInterface, typename DefImpl = IInterface, size_t storageSize = sizeof( DefType )> class ImplSwitch {
    IInterface* impl;
    char storage[storageSize];
    template<typename NewImplType> void createImpl()
    {
        typedef char check_storage_size[ sizeof( storage ) >= sizeof( NewImplType ) ];
        assert( impl == 0 );
        impl = new(storage) NewImplType;
    }
    void freeImpl() 
    {
        if( impl != 0 ) {
            impl->~IInterface();
            impl = 0;
        }
    }
public:
    ImplSwitch() : impl( 0 ) { createImpl<DefImpl>(); }
    ~ImplSwitch() { freeImpl(); }

    operator IInterface* () { return impl; }
    operator const IInterface* () const { return impl; }

    template<typename NewImplType> SwitchTo() 
    {
        freeImpl();
        createImpl<NewImplType>();
    }
};

The lifetime of an object of type T ends when:
— if T is a class type with a non-trivial destructor (12.4), the destructor call starts, or
— the storage which the object occupies is reused or released.

struct B {
  virtual void f();
  void mutate();
  virtual ˜B();
};
struct D1 : B { void f(); };
struct D2 : B { void f(); };
void B::mutate() {
  new (this) D2; // reuses storage – ends the lifetime of *this
  f();           // undefined behavior
  ...
}

Interface * i = 0;
void * storage = malloc(<size of storage for any implementation>);

Impl1 * impl1 = new (storage) Impl1;
i = impl1;
i->foo();
i->~Interface();

Impl2 * impl2 = new (storage) Impl2;
i = impl2;
i->foo();
i->~Interface();

free(storage);

class Interface {/*...*/};
class Implementation1 : public Interface {/*...*/};
class Implementation2 : public Interface {/*...*/};

Interface* i1 = new Implementation1();
Interface* i2 = new(i1) Implementation2();

i2->foo(); //Ok
i1->foo(); //???

A destructor is trivial if it is an implicitly-declared destructor and if:
— all of the direct base classes of its class have trivial destructors and
— for all of the non-static data members of its class that are of class type (or array thereof), each such class
has a trivial destructor.
Otherwise, the destructor is non-trivial.

KO>>Скорее всего ниоткуда, только что из этого следует? Не надо использовать старое значение i1.

class Interface {/*...*/};
class Implementation1 : public Interface {/*...*/};
class Implementation2 : public Interface {/*...*/};

Interface * i1 = 0;
aligned_storage<sizeof(<max implementation size>)>::type storage;

// ...

i1 = new (&storage) Implementation1();
i1->foo();

// ...

i1 = new (&storage) Implementation2();
i1->foo();

1. Ни в одном из классов в иерархии наследования не было определенных пользователем деструкторов
   
2. Ни в одном из классов в иерархии наследования не было полей с нетривиальным деструктором

ТКС>UB. Вообще, хотя бы деструктор предыдущей реализации надо вызвать перед placement new, ну и позаботиться о том, чтобы хватило памяти (sizeof(intf) >= sizeof любой из реализаций) под все реализации. И это все равно не гарантирует отсутствия проблем при оптимизации.

Деструктор, если он тривиальный, вызывать необязательно, UB будет только если размеры или выравние создаваемых объектов не соответсвуют используемой памяти.

Interface intf;

Interface* intf;
//...
intf = new (intf) T(); // происходит подмена VPTR