class A 
{
public:
    A();
    virtual void Delete()
    {
        // do something
        delete this;
    }    
protected:
    ~A()
    {
        // do somesing
    }
};

class B : public A
{
public:
    B();
protected:
    ~B()
    {
        // do something
    }
};


void main()
{
    A a0; // <- compilation error
    A a = new A;
    B b = new B;
    delete a; // <- compilation error
    a->Delete(); // OK
    delete b; // <- compilation error
    b->Delete(); // OK

}

P>Как запретить создавать объекты некого класса на стеке, я-то знаю — закрываем конструкор и делаем функцию static Object * Create();, которая будет создавать объекты в куче. Но вот проблема с анду — в том, что надо (очень хочется ) запреть в базовом классе создавать [b]наследников[b] на стеке. Наследников у нашего IUndoObject штук 100 не меньше, и всем закрывать конструктор и писать Create() не самый удачный выход, потому что это все равно не проверяется компилятором (ему-то гаду пофиг) — достаточно где-то завтыкать, или написать новый код, в котором забыть про Create, и все — упадешь и не заметишь. Да и вообще — это куча дублирования кода, и так сказать "мантра", которую надо помнить, знать и понимать.

class UndoMngr
{
//...
public:
template<typename T>
static T * Create()
{
T * result = new T();
// register Object...
return result;
}
//...
};
class IUndoObject
{
//...
friend class UndoMngr;
protected:
IUndoObject();
virtual ~IUndoObject();
//...
};

class action
{
public:
  virtual void run() = 0;
  virtual smart_ptr<action> get_undo_action() = 0;
  //...
};

class action_add : public action
{
public:
   virtual smart_ptr<action> get_undo_action();
   //...
};

class action_remove : public action
{
public:
   virtual smart_ptr<action> get_undo_action();
   //...
};

smart_ptr<action> action_add::get_undo_action(){
  return smart_ptr<action>(new action_remove(some_args));
}

smart_ptr<action> action_remove::get_undo_action(){
  return smart_ptr<action>(new action_add(some_args));
}
//...

void run(smart_ptr<action> a)
{
  a->run();
  undo_stack.add(a->get_undo_action());
}

class foo
{
foo()
{
volatile int test = 0;
VirtualQuery(&test, ... &mbi1,...);
VirtualQuery(this, ... &mbi2,...);
assert (mbi1.AllocationBase!=mbi2. AllocationBase);
}
};

А>class UndoMngr
А>{
А>//...
А>public:
А>template<typename T>
А>static T * Create()
А>{
А>T * result = new T();
А>// register Object...
А>return result;
А>}
А>//...
А>};
А>class IUndoObject
А>{
А>//...
А>friend class UndoMngr;
А>protected:
А>IUndoObject();
А>virtual ~IUndoObject();
А>//...
А>};

А>

class CBadUndoObject : public IUndoObject
{
public:
  CBadUndoObject() { /* some code */ }
  ~CBadUndoObject() { /* some code */ }
};

/* где-то в коде */

{
  pUndoMgr->BeginGroup();

  CBadUndoObject aBadUndoObject( pUndoMgr ); /* тут он за счет конструктора базового анду-объекта регится в анду-манагере */

  pUndoMgr->EndGroup(); /* в конце транзакции создание объекта регистрируется и засовывается в стек анду */

} /* тут 'aBadUndoObject' доблестно погибает, и даже разрегестрируется из анду-манагера, но потроха его остаются в стеке анду */

... где-то дальше в коде

void OnUndo()
{
  pUndoMgr->Undo(); /* и тут мы полезем в стек анду, вытащим указатель на 'aBadUndoObject' и попытаемся вернуть ему его прошлое состояние (в этом примере - состояние несуществования :) ), и на этой попытке и помрем, т.к. обратимся к указателю на мертвый объект*/
}

class CUndoObject {
    struct SecretSeed {};
    template<typename T> class Placeholder : public T { void checkSecretSeed( const SecretSeed& ) {} };
public:
    template<typename T>
    static T* CreateNew() { return new Placeholder<T>;
private:
    virtual void checkSecretSeed( const SecretSeed& ) = 0;
    
};

void AddObject(std::shared_ptr<Object> &obj);

//     Объект, который нельзя создать, иначе чем встроенной в него фабрикой...
class IDynCreatedObject {
public:
    virtual ~IDynCreatedObject() {}
    template<typename TDynCreatedObject> static TDynCreatedObject* CreateNew() 
        { return new objectPlaceholder<TDynCreatedObject>; }
    template<typename TDynCreatedObject> static TDynCreatedObject* CreateCopyOf( const TDynCreatedObject& toClone ) 
        { return new objectPlaceholder<TDynCreatedObject>( toClone ); }
    template<typename TDynCreatedObject> static TDynCreatedObject* CreateNew( TDynCreatedObject*& toInit ) 
        { return toInit = CreateNew<TDynCreatedObject>(); }

private:
    class secretSeed {};
    virtual secretSeed checkSecretSeed( secretSeed ) = 0;
    template<typename TDynCreatedObject>
    struct objectPlaceholder : TDynCreatedObject { 
        objectPlaceholder() {}
        objectPlaceholder( const TDynCreatedObject& other ) : TDynCreatedObject( other ) {}
        
        secretSeed checkSecretSeed( secretSeed ss ) { return ss; }
    };
};

#endif//!DynCreatedObject_h

struct testDCO : IDynCreatedObject {
//    secretSeed checkSecretSeed( secretSeed ss ) { return ss; }
};

struct testTestDCO {
//    testDCO forbiddenField;
};

void testIDynCreatedObject ()
{
//    delete new testDCO;
//    testDCO autoObj;
    testDCO* obj = testDCO::CreateNew(obj);    //    Тут нет UB, так как возврат из функции -- точка следования!
    delete obj->CreateCopyOf( *obj );
    delete obj;
}