Re: Order of destruction of static members and static objects
On Nov 27, 2:49 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
Juha Nieminen wrote:
Assume we have a class like this:
class A
{
class Container;
static Container container;
This is a declaration. Where is the definition?
You ask the necessary question.
public:
~A();
};
Assume that A::~A() does something with A::container (eg.
removes or changes an element from it or whatever).
Also assume that somewhere else there's a global
instantiation of A like this:
namespace { A anObject; }
The question is: Is it guaranteed that 'anObject' will be
destroyed before 'A::container'?
No, it's not guaranteed. What's guaranteed, however, is that
if they are created in some order, then they are destructed in
the reverse order.
And then answer it without knowing the answer. If the
definition is in the same translation unit, before this
statement, it is guaranteed. Otherwise not.
Because, obviously, if 'A::container' is destroyed first,
then the destructor of 'anObject' will be accessing a
destroyed Container object.
Yep.
I'd have to see the source of A::~A() first, before I was so
categorical:-). And also the declaration of Container. If
A::~A() doesn't access container, there's no problem. Same
thing if Container has a trivial destructor. (I'll admit that
with a name like Container, it's highly unlikely that the
destructor is trivial.)
If it's not guaranteed, then how can one use static members
safely?
Apparently you need 'A::container' to be a singleton. See any
of the existing implementations of that pattern. Most simple
ones actually create the singleton on demand (in freestore)
and never destroy it.
That's often the simplest and most appropriate solution. If
Container is a more general class (e.g. an std::vector), then
you can wrap it in a simple function to ensure the same
behavior. Another solution is to ensure that Container has a
trivial destructor.
--
James Kanze