Re: Virtual functions in constructors. Is it possible?

<code>
#include <iostream>
#include <stdexcept>
#include <cstdlib>
#include <memory>
using namespace std;

namespace g {
     int nObjectsAllocated = 0;
} // namespace g

class VirtualBase {
protected:
     class Initializer;
     friend class Initializer;

     class Initializer {
     public:

         Initializer() {
             cout << "Initializer" << endl;
             p = 0;
         }

         ~Initializer() {
             cout << "~Initializer" << endl;
             try {
                 if (p)
                     p->Init(); // call the virtual function
             } catch (...) {
                 p->InitFailed();
                 throw;
             }
         }
         // might be private if VirtualBase is declared as friend...

         void Register(VirtualBase* b) const {
             p = b;
         }
     private:
         mutable VirtualBase* p;
         // private and not implemented
         Initializer(const Initializer&);
         void operator =(const Initializer&);
     };
public:

     VirtualBase(const Initializer& i) {
         cout << "VirtualBase" << endl;
         i.Register(this);
     }
private:
     virtual void Init() = 0;
     // will be called immediately after the constructor
     // of the most derived class

     virtual void InitFailed() = 0;
     // will be called if Init failed. Should leave the object
     // in a destructable state.
};

// This is the actual hierarchy

class Base : public virtual VirtualBase {
public:

     static void* operator new( size_t size )
     {
         cout << "Allocation" << endl;
         ++g::nObjectsAllocated;
         return ::operator new( size );
     }

     static void operator delete( void* p )
     {
         cout << "Deallocation" << endl;
         --g::nObjectsAllocated;
         return ::operator delete( p );
     }

     Base(const VirtualBase::Initializer& i = Initializer()) : VirtualBase(i) {
         cout << "Base" << endl;
     }

     ~Base() {
         cout << "~Base" << endl;
     }

     void Init() {
         cout << "Base::Init()" << endl;
         #ifdef FAIL_INIT
             throw runtime_error( "Oops, `Init` failed." );
         #endif
     }

     void InitFailed() {
         cout << "Base::InitFailed() - could do something if needed" << endl;
     }
};

int main()
{
     int result = EXIT_FAILURE;
     try
     {
         auto_ptr<Base> p(new Base); // calls Base::Init.
         // We *need* an auto_ptr to ensure that the item will be
         // deleted in case of exception.
         result = EXIT_SUCCESS;
     }
     catch( exception const& x )
     {
         cerr << "!" << x.what() << endl;
     }

     if( g::nObjectsAllocated > 0 )
     {
         cerr << "!Memory leak." << endl;
     }
     cout << "Finished." << endl;
     return result;
}
</code>

So I must repeat my question : Where am I mistaking ?