Destruction of static member in a class with global instance - c++

Question

I have a class with a static non-primitive member. For example:
class SomeObject
{
... // something that will be destroyed in destructor,
// like an array pointer.
public:
SomeObject();
~SomeObject();
};
class MyClass
{
static SomeObject m_object;
public:
MyClass();
~MyClass(); // this will access m_object
static bool SetupStaticMember();
};
/// Implementation of SomeObject and MyClass ///
SomeObject MyClass::m_object;
bool dummy = MyClass::SetupStaticMember(); // Setup the values in m_object, for example,
// allocate memory that will be released in ~SomeObject().
MyClass g_my_global_class;
g_my_global_class is declared as global variable, so it's destructor is called after leaving main().
However, MyClass::m_object is static, so it will also be destroyed after main().
Is there any guarantee that ~MyClass() will execute before ~SomeObject() from MyClass::m_object? In other words, when the destructor of a global class instance is called, can I assume that the static members of this class are still there to be accessed, or does this depend on construction/destruction orders?
If the codes are written in this order, I think that g_my_global_class is constructed later, so it should be destructed first. Do things change if the line
MyClass g_my_global_class;
moves to another .cpp file and its file name causes the order to change?

Answer 1

First,
bool dummy = MyClass::InitStaticMember(); // m_object is initialized here
Doesn't actually intialize the static member. That happens at the line before
SomeObject MyClass::m_object;
So since you essentially have
SomeObject MyClass::m_object;
MyClass g_my_global_class;
and since objects are destroyed in the reverse order then g_my_global_class is destroyed before MyClass::m_object.
Now, if you move MyClass g_my_global_class; to a different translation unit then all bets are off. The ordering is only guaranteed in a single translation unit.

Answer 2

Is there any guarantee that ~MyClass() will execute before ~SomeObject() from MyClass::m_object?
Yes. Objects in static storage are destroyed reverse order of initialization.
Statically initialized objects such as MyClass::m_object and g_my_global_class are initialized in order of definition. Therefore MyClass::m_object which is defined first, is also initialized first, and destroyed last.
Do things change if the line ... moves to another .cpp file and its file name causes the order to change?
Yes, things change. Order of definition across translation units is unspecified, so there is no guarantee about the relative initialization order (and thus no guarantee about the relative destruction order).
The typical solution to dependencies between static objects is to use the initialization on first use idiom, which is simply replacing the use of a global static with a function that returns a reference to a local static:
class MyClass
{
static SomeObject& m_object() {
static SomeObject s;
return s;
}
};
Local static objects are initialized when execution first reaches the point of declaration; hence the name of the idiom.
Any object whose own initialization calls MyClass::m_object(), is guaranteed to be destroyed before the local static s is destroyed and therefore can rely on its existence for their entire lifetime - including the destructor and regardless of translation unit bounds.

Answer 3

Check this out if you're using visual studio - windows: otherwise you may have to use something similar such as __PRETTY_FUNCITON__, etc.
class SomeObject {
public:
SomeObject() {
std::cout << __FUNCTION__ << " was called: SomeObject created." << std::endl;
}
~SomeObject() {
std::cout << __FUNCTION__ << " was called: SomeObject destroyed." << std::endl;
}
};
class MyClass {
public:
static SomeObject m_object;
MyClass() {
std::cout << __FUNCTION__ << " was called: MyClass created." << std::endl;
}
~MyClass() {
std::cout << __FUNCTION__ << " was called: MyClass destroyed." << std::endl;
}
static bool setupStaticMember() {
std::cout << __FUNCTION__ << " was called... " << std::endl;
return true;
}
};
SomeObject MyClass::m_object;
bool dummy = MyClass::setupStaticMember();
MyClass gMyClass;
int main() {
_getch();
return 0;
}
Output in debugger console while waiting for key press:
SomeObject::SomeObject was called: SomeObject created.
MyClass::setupStaticMember was called...
MyClass::MyClass was called: MyClass created.
Then as key press is entered and console from debugger closes (visual studio 2017)...
MyClass::~MyClass was called: MyClass destroyed.
SomeObject::~SomeObject was called: SomeObject destroyed.
To test this out fully just go to the *.exe's path in the console directly and call the executable. You will see the same lines above while the application is running but after you press a key and enter to finish the application the last 2 lines are then called in that order.
These are all in the main.cpp file (same translation unit).
This does show the order that objects are created. Now if you are in a class hierarchy then you need to make sure you are virtualizing your classes for proper construction - destruction order.

Answer 4

Static member of a class is a class level variable and under the class scope. As a static member is under the scope of class only it is accessible from all the object instantiated from that class with :: (classname::static_variable) operator. As it is not a object variable you can not release from destructor of the class.
Suppose you have created ten objects from that class in various location in your codes and one object is going out of its scope and will call its destructor and if you release the static variable from that destructor what would happened in other objects? As they are all sharing the same static member. That is the reason a static member never initialized in a constructor.
Hence a static member will be release from the memory only when program exit.