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>