Re: newbie: C++ static initializer (constructor vs bool)
andrew_nuss@yahoo.com wrote:
This is obviously a newbie question. I know that constructors
for static class instances are invoked in different modules in
unpredictable order. My question is whether this is true of
static boolean variables as well.
The type has nothing to do with it. The difference is that
static initialization occurs before dynamic initialization. For
initialization to be static, the initialized type must have a
trivial constructor (which is the case of all built-in types,
like boolean, and all POD structs), and the initialization must
be from a constant expression. So:
bool b1 = true ; // static
bool b1 = f() ; // dynamic
For example, in the following code, I'm wondering if the
Digest::Hash() function can be called safely from other
initializers, which would be true if the "inited" boolean is
guaranteed to be set to its initial value before any static
constructors are invoked in any modules. If the same
unpredictability of static initializer order applies to
booleans then this code is unsafe. Which is the case?
As long as the initialization is static, it will occur before
any line of code you write (including code used in dynamic
initialization) takes place. Even before static initialization
(conceptually, at least---there's no way you can see the order)
is zero initialization. Not a few initialization tricks are
based on this as well.
// Digest.h
class Digest {
enum { RANGE = 1000 }; // 1000 precalculated values
static bool inited; // set to false in Digest.cpp
static int* array; // array of hash values created
by constructor (set to null in Digest.cpp)
static int LCG (int v); // slow computation of munged "v"
static void Init ()
{
array = reinterpret_cast<int*>(malloc(sizeof(int)*RANGE));
IMHO,
new int[ RANGE ]
would seem more appropriate to allocate the memory.
... fill array with precalc values
inited = true;
}
public:
// ??? can Hash() be called in different module during
// static C++ initializer time when inited is garbage true-like
value
// and therefore array is a garbage pointer value, then Crash!
static int Hash (int v)
{
if (!inited) Init();
if ((unsigned int)v < (unsigned int)RANGE)
return array[v];
else
return LCG(v);
}
};
// Digest.cpp
bool Digest::inited = false;
int* Digest::array = 0;
int Digest::LCG (int v)
{
....
}
Just a question, but is there any reason why you don't use the
standard singleton pattern here?
--
James Kanze GABI Software
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]