How is static variable initialization implemented by the compiler?

Question

I'm curious about the underlying implementation of static variables within a function.

If I declare a static variable of a fundamental type (char, int, double, etc.), and give it an initial value, I imagine that the compiler simply sets the value of that variable at the very beginning of the program before main() is called:

void SomeFunction();  int main(int argCount, char ** argList) {     // at this point, the memory reserved for 'answer'     // already contains the value of 42     SomeFunction(); }  void SomeFunction() {     static int answer = 42; } 

However, if the static variable is an instance of a class:

class MyClass {     //... };  void SomeFunction();  int main(int argCount, char ** argList) {     SomeFunction(); }  void SomeFunction() {     static MyClass myVar; } 

I know that it will not be initialized until the first time that the function is called. Since the compiler has no way of knowing when the function will be called for the first time, how does it produce this behavior? Does it essentially introduce an if-block into the function body?

static bool initialized = 0; if (!initialized) {     // construct myVar     initialized = 1; } 

Answer 1

This question covered similar ground, but thread safety wasn't mentioned. For what it's worth, C++0x will make function static initialisation thread safe.

(see the C++0x FCD, 6.7/4 on function statics: "If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.")

One other thing that hasn't been mentioned is that function statics are destructed in reverse order of their construction, so the compiler maintains a list of destructors to call on shutdown (this may or may not be the same list that atexit uses).