Re: static member initialization
On Sep 15, 11:01 pm, "Frank Neuhaus" <fneuh...@uni-koblenz.de> wrote:
It seems from the above that
* Only someFunc (plus possibly functions called by
someFunc) uses the var.
Thats not correct unfortunately. The static variable is used
to make a list of all classes of a certain type.
* The use of a pointer is not from any particular reason,
i.e. it's not in order to circumvent ordinary lifetime
rules (destruction order).
The pointer was an attempt to trick the initialization order
thing. If the vector is not a pointer, and it is accessed
before it is initialized, it actually crashes - with the
pointer at least it doesnt crash (though im assuming it is
definately not a correct solution).
I have given this a bit more thought and came up with this:
class MyClass
{
public:
static void myfunc();
private:
static std::vector<int>& getvec() { static std::vector<int> v; retu=
rn
v; };
};
}
now myfunc can simply do
void MyClass::myfunc()
{
std::vector<int>& myvec=getvec();
// do sth with myvec
}
That seems like a viable method to circumvent the problem, right?
In a single threaded environment, or if you guarantee that
getvect is called at least once before threading starts. And if
you don't try to use the vector in any destructors to static
objects.
The pattern, here, is known as a singleton. I usually
implement it slightly differently, using a pointer:
std::vector< int >& getvec() ;
std::vector< int >* vector = &getvec() ;
std::vector< int >&
getvec()
{
if ( vector != NULL ) {
vector = new std::vector< int > ;
}
return *vector ;
}
This ensures that the getvec() function will be called at least
once before entering main (and thus, hopefully, before threading
is started), and that the vector itself is never destructed, so
it will be available in destructors as well.
--
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