Re: Functional Local Static Zero Initialization - When?

A working draft of theC++standard I was able to obtain says
the following in section 6.7.4:
The zero-initialization(8.5) of alllocalobjects withstatic
storage duration (3.7.1) orthreadstorage duration (3.7.2) is
performed before any otherinitializationtakes place.
First, the only addition for C++0x is thethreadstorage
duration, so I assume the sentence was the following for
previous versions of the standard:
The zero-initialization(8.5) of alllocalobjects withstatic
storage duration (3.7.1) is performed before any other
initializationtakes place.
The criteria "before any otherinitialization" is a little
ambiguous here. Does this mean any otherinitializationinside
thefunctionthestaticresides, or any otherinitialization
the entire program may perform.

Basically, I'm trying to implement something like the
following to allow forthreadsafefunctionlocalstatic
initializationwhile maintaining proper destructor ordering
atexit.
template<class T>
struct Once
{
  T *_obj;
  long _once;
  Once()
  {
    while (1)
    {
      long prev = InterlockedCompareExchange(&_once, 1, 0);
      if (0 == prev) // got the lock
        break;
      else if (2 == prev) // The singleton has been initial=

        return _obj;
      else {
        // Anotherthreadis initializing the singleton: must w=

        assert(1 == prev);
        sleep(1); // sleep 1 millisecond

      }
    }
    assert(_obj == 0);
    _obj = new T;
    InterlockedExchange(&_once, 2);
    return _obj;
  }
  ~Once() { delete _obj; }
  inline T& operator *() { return *_obj; }
  inline T* operator ->() { return _obj; }
  inline operator T* () { return operator ->(); }
};
If I can guarantee that the memory of the object is
zero-initialized during "staticinitialization",