Are static data members initialized before all class objects?

Question

For example:

#include<iostream>
using namespace std;
class A
{
    public:
    A(){cout<<k<<endl;}//make some output
    static int k;
};
A a;//before `k`'s definition
int A::k=666;
int main()
{

}

Is the answer guaranteed to be 666 (I've tested it in gcc8.1.0 the answer is 666) or causing undefined behavior?

What's more, in this example, object a and definition A::k are in the same translation unit, what will happen if they are in different units, since

Initialization of static variables in different translation units is indeterminately sequenced

From my point of view, since in the same TU the initializaition order is fixed, the answer of the example above should be undfined.

Undefined behavior, anything can happen for the multiple translation units. — Matthieu Brucher, Feb 26 '19 at 11:33
Possible duplicate of [C++ static initialization order](https://stackoverflow.com/questions/1005685/c-static-initialization-order) — Matthieu Brucher, Feb 26 '19 at 11:36
@MatthieuBrucher Not that duplicate. Actually `within a single translation unit, initialization of these non-local variables is always sequenced `. But this example seems to obey that rule. — choxsword, Feb 26 '19 at 11:39
@MatthieuBrucher And I'm asking about the relationship between class object and static member of that class, which is a special case of that question. — choxsword, Feb 26 '19 at 11:41

StoryTeller - Unslander Monica · Accepted Answer · 2019-02-26T11:58:03.660

4

If you were to make the constructor a non-inline function, yes, it would be guaranteed to be the value you expect.

k will be subject to constant initialization (on account of the constant initializer), while a's initialization is dynamic. All static initialization happens before dynamic initialization of static objects. But even if k was initialized dynamically:

[basic.start.dynamic] (emphasis mine)

4 It is implementation-defined whether the dynamic initialization of a non-local non-inline variable with static storage duration is sequenced before the first statement of main or is deferred. If it is deferred, it strongly happens before any non-initialization odr-use of any non-inline function or non-inline variable defined in the same translation unit as the variable to be initialized. It is implementation-defined in which threads and at which points in the program such deferred dynamic initialization occurs.

And a non-inline constructor qualifies for such a function. This is the basis for the Schwarz Counter technique.

But in your example, the c'tor is an inline function. So it's only due to constant initialization that you get 666. Should the initializer not be a constant expression, a would be undergo dynamic initialization before k according to declaration order in the same TU.

edited Feb 26 '19 at 11:58

answered Feb 26 '19 at 11:44

StoryTeller - Unslander Monica

165,132
21
377
458

So if that static member is dynamically initialized, then the example may cause UB? – choxsword Feb 26 '19 at 11:52
@bigxiao - Well, no. If constant initialization doesn't happen, then a variable is zero-initialized before dynamic initialization. So this may print `0` if `k` was initialized by something like `std::rand()`. – StoryTeller - Unslander Monica Feb 26 '19 at 11:58
But ultimately, this is not something you want to be messing with, or depending on the fine print of. – StoryTeller - Unslander Monica Feb 26 '19 at 11:58
So is it true that **class static data members are always initialized before all objects of that class**? Since static init always happens before dynamic init? – choxsword Feb 26 '19 at 12:03
@bigxiao - I never say "always" when it comes to C++. Each example needs to be analyzed by itself. – StoryTeller - Unslander Monica Feb 26 '19 at 12:05
But I can't find a counter-example of that inference, since static init always happens before dynamic init. – choxsword Feb 26 '19 at 12:07
@bigxiao - If you are referring to one TU, then I can't either. But I still would not use absolute terms. – StoryTeller - Unslander Monica Feb 26 '19 at 12:21

score 2 · Answer 2 · answered Feb 26 '19 at 11:44

Are static data members initialized before all class objects?

Depends. All objects with static storage duration, which includes all static data members, are initialised before main. But if you have class objects with static storage duration, then those class objects may be initialised before static data members.

Is the answer guaranteed to be 666

Yes.

causing undefined behavior?

No UB here.

what will happen if they are in different units

Initialisation of the static member is constant, while the constructor of a is called during the dynamic initialisation of static objects. Constant initialisation phase is before dynamic phase. Thus it doesn't matter in this case whether they are declared in different TU's.

score 0 · Answer 3 · answered Feb 26 '19 at 12:00

Static member is given a separate room. Whether you initialize it before object creation of the class or not, will not have any effect. The program will run without undefined behavior.

For example In C#, the if the static member's value is not set, it is given 0 value by the compiler.

You can get/set value of static member after the object creation of the class
You can set before as well, as you know already.

After setting it as 666, other objects made of that class A will get it value as 666

Are static data members initialized before all class objects?

3 Answers3