Why Does Static Member Initialization in Templated Classes Behave Differently?

Static Member Initialization Complications in Templated Classes

Static member initialization in C is a widely used technique, but it can become complex when dealing with templated classes. In non-templated classes, a nested helper struct can be employed for initialization, but this approach falls short when the enclosing class is templated.

Consider the following simplified example:

<code class="cpp">struct A
{
    static std::string mA;
    static InitHelper mInit;

    static const std::string& getA() { return mA; }
};
std::string A::mA;
A::InitHelper A::mInit;


template<class t>
struct B
{
    static std::string mB;
    static InitHelper mInit;

    static const std::string& getB() { return mB; }
    static InitHelper& getHelper() { return mInit; }
};
template<class t>
std::string B<t>::mB;
template<class t>
typename B<t>::InitHelper B<t>::mInit;

int main()
{
    std::cout ::getB() ::getHelper(); // [2]
}</t></t></class></t></class></class></code>

Expected Behavior:

When [1] is uncommented and [2] is commented, we would expect B::mB to be initialized to "Hello, I'm B.". However, this does not occur.

Actual Behavior:

• With [1] and [2] commented: No side effects occur.
• With [1] uncommented: B::getB() returns an empty string.
• With [1] and [2] uncommented: B::mB is correctly initialized.
• With [1] commented and [2] uncommented: A segmentation fault occurs during static initialization.

Reason for the Discrepancy:

According to the ISO/IEC C 2003 standard, the template member is implicitly instantiated when referenced in a context that requires its definition to exist. However, static data member initialization (and any associated side effects) only occur when the static data member is explicitly used. This means that if a template member is only referenced in uninstantiated templates or in other contexts that do not require its full instantiation, its static data members will not be initialized.

In the example, B::getB() requires B::mB to exist, but this only forces the instantiation of the member template declaration, not its definition (including the initializer). In contrast, B::getHelper() does require the definition of B::mInit because it returns a reference to it.

Solution:

The standard proscribes that definitions of explicitly specialized class template static data members have ordered initialization, while other class template static data members have unordered initialization. To ensure consistent initialization order, one must use explicit specializations.

The above is the detailed content of Why Does Static Member Initialization in Templated Classes Behave Differently?. For more information, please follow other related articles on the PHP Chinese website!