C++ static member variable scope

Question

The title basically says it all, i wonder when static members of a c++ class are initialized and when they go out of scope.

I need this for the following problem. I have many objects of a class Foo and each object needs access to a resource, encapsulated by another class Bar. Synchronization is not an issue, so i want all objects to share the same Bar instance.

I'm using a simple managed pointer for reference counting.

Can i do the following:

class Foo {
private:
    static managed_pointer<Bar> staticBar;
public:
    Foo() {
        if(!staticBar)
            staticBar = new Bar;
    }
    /*
     * use staticBar in various non-static member functions
     */
};

managed_pointer<Bar> Foo::staticBar = NULL;

the managed_pointer staticBar should delete the Bar object as soon as it goes out of scope - but when does this happen? when the last instance of Foo is destructed? on application exit?

Thanks for your advice!

Answer 1

statics and globals are initialized right before the program starts (before main is called, the program actually starts before that) and go out of scope after main exits.

Exceptions - local statics (static variables declared inside functions) and unused template class staticmembers.

It has nothing to do with the number of instances.

Answer 2

The standard does not specify a precise order of initialization, it is implementation specific. They will be instantiated at the start of the program and deallocated at the end.

You have to be very careful with what you are doing, because if you have some other static objects that rely on this object to exist, it's UB. There is no telling in what order they will be initialized.

You could possibly look into something like boost::call_once to ensure it's initialized once, but I wouldn't rely on the order the statics are initialized.

For all I know, you code would work, but I've been bitten by the static initialization issue before so I wanted to warn you.

EDIT: Also in your code, when the managed_ptr will go out of scope (end of program), it will delete the memory allocated automatically. But you should not do anything non-trivial in Bar's destructor as you may trigger UB by calling into other free'd instances or even code that has been removed (as it happened to me once where a dynamic library had been removed). Essentially you are in a minefield, so watch out.