class Interface {
public:
  virtual void someFun() =0;
};
class Derived1: public Interface {
public:
  void someFun() {
    //реализация...
  }
};
class Derived2: public Interface {
public:
  void someFun() {
    //реализация...
  }
};

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

int main() {
  User user;
  user.changeIntfRealization<Derived1> ();
  user.intf.someFun(); // вызовется реализация Derived1

  user.changeIntfRealization<Derived2> ();
  user.intf.someFun(); // вызовется реализация Derived2
}

// класс у которого хочется круто менять поведение
class YourFlexibleObject {
 private:
  Strategy * strategy_;

 public:
  // вот этот метод меняет стратегию
  void setStrategy(Strategy * strategy) { this->strategy_ = strategy; }

  // интерфейсная часть, которую хочется менять:
  int getSmth(Arg1 arg1, Arg2 arg2) {
    ASSERT_VALID(strategy_);
    return strategy_->getSmth(this, arg1, arg2);
  }

  void doSmth(Arg3 arg3, Arg4 arg4) {
    ASSERT_VALID(strategy_);
    return strategy_->getSmth(this, arg3, arg4);
  }

  // ...
};

class Yanus
{
    Interface *_if1, *_if2;
    
public:
    Yanus(Interface *if1, Interface *if2)
        :_if1(if1), _if2(if2){}

    ~Yanus()
    {
        delete _if1;
        delete _if2;
    }

    Interface *operator->() { return _if1; }
    const Interface *operator->() const { return _if1; }
    void SwitchFace() { std::swap(_if1, _if2); }
};

class Interface 
{
public:
    virtual void foo() = 0;
    virtual ~Interface() = 0 {};

};

class InterfaceImpl1 : public Interface
{
public:
    virtual void foo()
    {
        printf("InterfaceImpl1 this=0x%x\n", this);
    }
};

class InterfaceImpl2 : public Interface
{
public:
    virtual void foo()
    {
        printf("InterfaceImpl2 this=0x%x\n", this);
    }
};

class Yanus
{
    void *p;
    Interface *i;
    size_t l;

public:
    Yanus(size_t prealloc_size = 0) 
        :p(0), i(0), l(0)
    {
        if (prealloc_size)
        {
            p = malloc(prealloc_size);
            if (p) l = prealloc_size;
        }
    }

    ~Yanus()
    {
        if (i)i->~Interface();
    }

    Interface *operator->() { return i; }
    const Interface *operator->() const { return i; }
    template<class IFIMPL>
    void ChangeFace() throw(std::bad_alloc)
    { 
        if (i) 
        {
            i->~Interface();
            i = 0;
        }

        if (sizeof(IFIMPL)>l)
        {
            p = realloc(p, sizeof(IFIMPL));
            if (!p)
            {
                l = 0;
                throw std::bad_alloc();
            }
            l = sizeof(IFIMPL);
        }

        i = new (p) IFIMPL ();
    }
};

void test_yanus()
{
    Yanus y;
    y.ChangeFace<InterfaceImpl1>();
    y->foo();
    y.ChangeFace<InterfaceImpl2>();
    y->foo();
}

template <class IMPL1, class IMPL2>
class Yanus
{
    char buf[max(sizeof(IMPL1), sizeof(IMPL2))];
    Interface *i;

public:
    Yanus() : i(0)
    {
    }

    ~Yanus()
    {
        if (i)i->~Interface();
    }

    Interface *operator->() { return i; }
    const Interface *operator->() const { return i; }
    
    void ChangeFace(bool second)
    { 
        if (i) 
        {
            i->~Interface();
            i = 0;
        }

        i = second ?  
            (Interface *)new (&buf[0]) IMPL1 () 
            : (Interface *)new (&buf[0]) IMPL2 ();
    }
};

class Interface {
public:
  virtual void someFun() =0;
  virtual ~Interface(){}
};
class Derived1: public Interface {
public:
  void someFun() {
    //реализация...
  }
};
class Derived2: public Interface {
public:
  void someFun() {
    //реализация...
  }
};

class User { // потребитель
public:
  char buff[sizeof(Interface)]; // at least sizeof(Interface)
  Interface *intf;
  User() : intf(0){
  }
  ~User(){
    Release(); 
  } 
  template <class T> 
  void changeIntfRealization() {
    static_assert(size_of(T) <= size_of(buff), "Ouch");
    Release();
    intf =  new (&buff) T();   
  }  
private:
  void Release() {
    if (intf) intf->~Interface(); 
    intf = 0;
  }
};

int main() {
  User user;
  if (!user.intf)
    cout << "not initialized yet!" << endl;

  user.changeIntfRealization<Derived1> ();
  user.intf->someFun(); // вызовется реализация Derived1

  user.changeIntfRealization<Derived2> ();
  user.intf->someFun(); // вызовется реализация Derived2
}

А>  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

A>>Нафига вообще менять VPTR??

V>Что-то ваш паттерн стратегия напоминает паттерн Pimpl

class ResultSet {
private:
  Strategy s;
  DataProvider p;

public:
  Row getRow(int index) {
    if (s != null) {
       // иное поведение если есть стратегия получения (например из кэша)
       return s->getRow(p, index);
    }
    return rowCollection->fetchRow(index);
  }

  void applySecurityConstraint(SecurityConstraint c) {
    // а вот этот метод, положим, немыслим без стратегии
    ASSERT_VALID(s);
    s->applySecurityConstraint(p, c);
  }

  RowMetadata getRowMetadata() {
    // а для этого метода нет какой-то особой стратегии
    return p->getRowMetadata();
  }
}

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

Interface* intf;
void * storage;
//...
intf = new (storage) T();

R>А как еще можно "допилить" это пример? Если "мы просто используем память существующего объекта для создания нового", то какие типы могут иметь существующий и новый объекты?

C>http://www.rsdn.ru/forum/cpp/4221864.aspx

Автор: Caracrist
Дата: 05.04.11

char buff[sizeof(Interface)]; // at least sizeof(Interface)

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

KO>Interface* intf;
KO>void * storage;
KO>//...
KO>intf = new (storage) T();
KO>

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

template <class T> 
void changeIntfRealization() {
  static_assert(size_of(T) <= size_of(buff), "Ouch");
  Release();
  intf =  new (&buff) T();   
}

intf =  new (buff) T();

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

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

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

KO>free(storage);
KO>

class User { // потребитель
public:
  Interface* intf;
  template <class T> changeIntfRealization() {
    delete intf;
    intf = new T;
  }  
};

using boost::shared_ptr;

class User { // потребитель
public:
  shared_ptr<Interface> intf;
  User() {/*Не нужен*/}
  ~User(){/*Не нужен*/} 
  template <class T> 
  void changeIntfRealization() {
    intf.reset(new T());   
  }  
};

Хочу использовать реализации интерфейсов без динамической реаллокации объектов реализующих их

R>template <class T> 
R>void changeIntfRealization() {
R>  static_assert(size_of(T) <= size_of(buff), "Ouch");
R>  Release();
R>  intf =  new (&buff) T();   
R>}  
R>

  void Release() {
    if (intf) intf->~Interface(); 
    intf = 0;
  }

R>intf =  new (buff) T();   
R>

Interface*
// а также
//shared_ptr<Interface>
//auto_ptr<Interface>

A>pimpl да не тот

class Strategy : public StrategyBase;

E>Что-то сильно я сомневаюсь, что можно так вольно обращаться с полями. В конце концов, например, деструктор класса позовёт деструктор поля, а там уже совсем и не то...

#include <malloc.h>
#include <new.h>

struct Base
{
  int a;
  Base() {}
  virtual void foo() { ++a; printf("foo Base, %d\n",a);  }
};

struct Particular: public Base
{
  Particular() {}
  virtual void foo() { printf("foo Particular, %d\n",a);  }
};

int main()
{
   void* memory = calloc(1, sizeof Base); 
  
   Base* obj = new(memory) Base();
   obj->foo();
   new(memory) Particular();
   obj->foo();

   free(memory);
   return 0;
}

CS>   Base* obj = new(memory) Base();
CS>   obj->foo();
CS>   new(memory) Particular();
CS>   obj->foo();
CS>

   Base* obj1 = new(memory) Base();
   obj1->foo();
   Base* obj2 = new(memory) Particular();
   obj2->foo();

CS>>   Base* obj = new(memory) Base();
CS>>   obj->foo();
CS>>   new(memory) Particular();
CS>>   obj->foo();
CS>>

void* a = new(memory) Base();
void* b = new(memory) Particular();

(void*)a == (void*)b

sizeof Base != sizeof Particular

CS>   Base* obj = new(memory) Base;
CS>   obj->foo();
CS>   new(memory) Particular; //!!! 1
CS>   obj->foo();               //!!! 2
CS>

E>>Что-то сильно я сомневаюсь, что можно так вольно обращаться с полями. В конце концов, например, деструктор класса позовёт деструктор поля, а там уже совсем и не то...

class struct {
    Base Agg;
    void Ups() {
        new(&agg) Particular;  // IMHO, так точно нехорошо делать...
    }
};

CS>>void* a = new(memory) Base();
CS>>void* b = new(memory) Particular();
CS>>

CS>>(void*)a == (void*)b
CS>>

(void*)(b + 1) != (void*)b + sizeof(*b)

struct Base { virtual ostream& F() { return std::cout << "Base"; } };
extern void magic_gop_swap( base* ); // тут может сидеть наш хак...
struct Dir : Base { virtual ostream& F() { return std::cout << "Dir"; } };

void test_it()
{
    Base& b = *new Dir;
    b.F() << std::endl; 
    magic_gop_swap( &b )
    b.F() << std::endl; 
    delete &b;
}

void test_it()
{
    Base& b = *new Dir;
    std::cout << "Dir" << std::endl; 
    magic_gop_swap( &b )
    delete &b;
    std::cout << "Dir" << std::endl; 
}

Повторяю: ВСЁ

E>>Суть хака в том, что мы используем всё тот же указатель...

E>>А ещё крупнее слабо написать?

O>Запросто. ВСЕ

А У МЕНЯ ДЛИНЬШЕ И ТОЛЩЕ!!!

A destructor is trivial if it is neither user-provided nor deleted and if:
— the destructor is not virtual,
— 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.

class User {
public:

  Interface intf;
  template <class T> changeIntfRealization() {
    new (&intf)T();
  }  
};

class User {
public:

  char buf[достаточно большое число]; 
  Interface* intf;

  User() { intf = new (buf)T(); }
  
  template <class T> changeIntfRealization() {
    new (intf)T();
  }  
};

class User {
public:

  char buf[достаточно большое число]; 
  Interface* intf;

  User() { intf = new (buf)T(); }
  
  template <class T> changeIntfRealization() {
    intf = new (intf)T();
  }  
};

class User {
public:

  char buf[достаточно большое число]; 
  Interface* intf;

  User() { intf = new (buf)T(); }
  
  template <class T> changeIntfRealization() {
    intf = new (buf)T();
  }  
};

Это отличается заказом памяти. Собственно разница состоит в "malloc(<size of storage for any implementation>);"