Re: Order of destruction of static members and static objects

From:

James Kanze <james.kanze@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Mon, 30 Nov 2009 01:50:47 -0800 (PST)

Message-ID:

<a1208b64-f8a6-432e-981f-edc79bef81d0@a21g2000yqc.googlegroups.com>

On Nov 28, 3:36 pm, Juha Nieminen <nos...@thanks.invalid> wrote:

James Kanze wrote:

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.

  How can you implement safely something like this?

// Header file
// -----------
class A
{
    static std::vector<int> sharedContainer;

    A(const A&);
    A& operator=(const A&);

public:
    A();
    ~A();
};

// Source file
// -----------
std::vector<int> A::sharedContainer;

A::A() { sharedContainer.push_back(0); }
A::~A() { sharedContainer.pop_back(); }

  If somewhere else you have something like:

namespace { A a; }

then the constructor might be accessing an unconstructed
std::vector, and the destructor might be accessing a destroyed
std::vector.

Yes. And the push_back/pop_back mean that you can't use int[]
and static initialization:-).

Construction safety could be ensured by changing the container to:

namespace
{
    std::vector<int>& sharedContainer()
    {
        static std::vector<int> container;
        return container;
    }
}

But does that ensure that it's not accessed after it has been
destroyed? If not, how do you make sure it's not?

std::vector< int >&
    sharedContainer()
    {
        static std::vector< int >* theOneAndOnly = new std::vecctor< int >;
        return *theOneAndOnly;
    }

The standard singleton idiom, in fact.

--
James Kanze