Re: Functional Local Static Zero Initialization - When?
On Dec 5, 3:38 am, Brian Cole <col...@gmail.com> wrote:
A working draft of the C++ standard I was able to obtain says
the following in section 6.7.4:
The zero-initialization (8.5) of all local objects with static
storage duration (3.7.1) or thread storage duration (3.7.2) is
performed before any other initialization takes place.
First, the only addition for C++0x is the thread storage
duration, so I assume the sentence was the following for
previous versions of the standard:
The zero-initialization (8.5) of all local objects with static
storage duration (3.7.1) is performed before any other
initialization takes place.
The criteria "before any other initialization" is a little
ambiguous here. Does this mean any other initialization inside
the function the static resides, or any other initialization
the entire program may perform.
I don't see any ambiguity. "Before any other initialization"
means "before any other initialization".
Of course, if the compiler can determine that a conformant
program cannot see the difference... I rather suspect that no
implementation actually initializes the thread local storage
before the thread using it is created.
Basically, I'm trying to implement something like the
following to allow for thread safe function local static
initialization while 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 initialized.
return _obj;
else {
// Another thread is initializing the singleton: must wait.
assert(1 == prev);
sleep(1); // sleep 1 millisecond
That's one second, not one millisecond. At least on Posix
platforms, and I'm pretty sure Windows as well. (There is no
C++ standard function sleep.)
}
}
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 "static initialization",
It will be if the object has static storage duration. Otherwise
not.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34