Re: Guarantee of side-effect free assignment

I think one of the problems with your solution with a randomly throwing

constructor could be a compiler can still rewrite it like this:

   Singleton* Singleton::instance()
   {
       if (pInstance == 0)
       {
           Lock lock;
           if (pInstance == 0)
           {
             // we know pInstance is 0 here
               pInstance = // Step 3
               operator new(sizeof(Singleton)); // Step 1
             try {
               new (pInstance) Singleton; // Step 2
             } catch(...) {
               delete (void*)pInstance;
               pInstance=0;
               throw;
             }
           }
       }
       return pInstance;
   }

And this transformation is legal (at least I think) as long as
Singleton::Singleton() (even in case of an exception) doesn't call
Singleton::instance() (and the allocation and deallocation function
likewise). You could only see the pointer to the non-constructed from an
async signal (but that's OK, because even the pointer is not sig_atomic_t,
so can be anything in an async signal) or from a different thread, but the
standard doesn't say anything about threads.