静态成员函数初始化静态成员变量 - 用法和风险？

Question

In the case of In MyClass.h

class MyClass 
{
    static vector<type> types;
    static vector<type> createTypes();
}

In MyClass.cpp

vector<type> MyClass::types = createTypes();

MyClass::MyClass()
{
}

When will be createTypes() executed and does this method of initializing a static variable involve any risks?

Answer 1

The function will be called along with other static initializers, before main() starts. You don't risk anything more than with other means of static initialization.

Keep in mind tough that all static initializers should be designed to avoid triggering a SIOF -- Static Initialization Order Fiasco.

Static initializers in the same translation unit are executed in the order of their declaration in the file. However, initialization order across multiple translation units is not defined. A SIOF arises when a static initializer depends on another, which is in another translation unit.

Then, depending on the phase of the Moon, either both objects will initialize in the right order and everything will work, or they will initialize in the opposite order and you'll use a not-yet-constructed object -- Undefined behaviour ensues.

The SIOF-guard pattern avoids this by replacing static variables like the following :

std::list<Foo> gFoos;

... with a function that contains the variable as a local static :

std::list<Foo> &gFoos() {
    static std::list<Foo> theList;
    return theList;
}

This way, the variable is always initialized on the first call of the function, and it's impossible to access it before its construction.