initialization of the static variables

Question

I've just read that if I want to be sure about the initialization order it will be better to use some function which will turn global variable into local(but still static), my question, do I need to keep some identifier which tells me that my static object has already been created(the identifier inside function which prevent me from the intialization of the static object one more time) or not? cause I can use this function with initialization in different places, thanks in advance for any help

Answer 1

The first question is do your static lifetime objects care about the order they are initialized?

If true the second question is why?

The initialization is only a problem if a global object uses another global object during its initialization (ie when the constructor is running). Note: This is horrible proactive and should be avoided (globals should not be used and if they are they should be interdependent).

If they must be linked then they should be related (in which case you could potentially make a new object that includes the two old ones so that you can control their creation more precisely). If that is not possible you just put them in the same compilation unit (read *.cpp file).

Answer 2

As far as the standard is concerned, initialization of a function-scope static variable only happens once:

int *gettheint(bool set_to_four) {
    static int foo = 3; // only happens once, ever
    if (set_to_four) {
        foo = 4;   // happens as many times as the function is called with true
    }
    return &foo;
}

So there's no need for gettheint to check whether foo has already been initialized - the value won't be overwritten with 3 on the second and subsequent calls.

Threads throw a spanner in the works, being outside the scope of the standard. You can check the documentation for your threading implementation, but chances are that the once-onliness of the initialization is not thread-safe in your implementation. That's what pthread_once is for, or equivalent. Alternatively in a multi-threaded program, you could call the function before creating any extra threads.