C++ Controlling destructor order for global objects

Question

I've got a class (A) that accesses (indirectly via a static method) a static variable (an STL container) in another class (B) in its constructor and destructor.

A objects may be global, global constants, static members of another class, stored in other classes (which may themselves have global or static instances) or basically anywhere else a c++ object can be.

If an A object is constructed before the static members in B or destructed after the static members in B, it will cause a crash at some point (usually an access violation).

Is there some way to guarantee that all instances of class A (except those that have leaked, since by definition there "lost" and so wont be destructed any way) are constructed after and destructed before B's static variable?

I've seen some solutions for making a specific variable be constructed/destructed before/after another, however not a general case of all instances of a given type so am not sure how to approach this.

Answer 1

No. This is known as the static-initialization fiasco. The order that objects get constructed prior to entering main is unspecified. The only guarantee is that it happens.

What you can do is lazy-initialize. This means your objects won't be initialized until you use them. Such as:

struct A { /* some data */ };
struct B { B(void){ /* get A's data */ } };

A& get_A(void)
{
    static A instance;
    return instance;
}

B& get_B(void)
{
    static B instance;
    return instance;
}

You use get_A and get_B to get the global instances. The part where B uses A should use get_A, and your use of B should be with get_B. Note the get_B is optional in your case.

What happens when B is first created? (Either globally or in the function) The constructor will call get_A and that's where A will be created. This let's you control the order things get constructed.

Note I think I reversed your A and B.

Answer 2

Static initialization order fiasco.

Answer 3

In general, no such method. There are workarounds, though. You can get an object with global scope and a slightly-less-than global lifetime by having a global pointer and initializing/destructing it in main/WinMain. Also, you place your global state to be destructed last in a ref-counted heap object.

Also, consider redesign :)

Answer 4

The book "Modern C++ Design" covers this issue nicely.

Google Books contains scans of much of it - see section 6.5 (page 135) - link.

Answer 5

You can handle this cleanly, by putting pointers to the objects in global space, then newing them in the desired order in your main, and destroying them in the desired order at the end of the main.

Answer 6

As others pointed, there is no standard and portable way to solve this problem, due to the Static initialization order fiasco issue.

However, you should be able to solve your problem by applying a bit of design, so you gain a degree of control when (and how) objects of A and B are constructed. Take a look on design patterns like creational pattern Singleton it is considered in many (if not most) cases as anti-pattern, despite it is worth to learn about it. Also look at to Monostate pattern which may be used as a bit better Singleton. These patterns can help to control object creation and lifetime, so things are properly initialized before use.

Generally, it's a good idea to avoid globals - sticking to deglobalisation is a good idea.