Subscript out of range when removing element from set - c++11

Question

This is a simplification of an issue I encountered in another project.
Say I have the following class:
class MyClass {
public:
MyClass() {
std::cout << "MyClass constructed\n";
Instances().insert(this);
}
~MyClass() {
std::cout << "MyClass destructed\n";
Instances().erase(this);
}
static std::unordered_set<MyClass*>& Instances() {
static std::unordered_set<MyClass*> _instances;
return _instances;
}
};
It has a static unordered_set that it uses for keeping track of existing instances of the class. When an instance is constructed, its address is added to the set; when an instance is destroyed, its address is removed from the set.
Now, I have another class that has a vector of shared_ptrs containing instances of MyClass:
struct InstanceContainer {
std::vector<std::shared_ptr<MyClass>> instances;
};
A key point here is that there is a global instance of this class above main. This seems to be part of the problem, because declaring the class inside of main does not produce the issue.
Inside of main, I do the following (say the global instance of InstanceContainer is called container):
container.instances.emplace_back(std::shared_ptr<MyClass>(new MyClass));
Everything is fine until the program terminates, when I get a read access violation ("vector subscript out of range") when Instances().erase(this) is executed in MyClass's destructor.
I thought that maybe I was attempting to erase the instance from _instances multiple times (hence the couts)-- However, the contructor is only called once, and the destructor is only called once, as you'd expect. I found that when this happens, _instances.size() is equal to 0. The weird thing is, it's equal to 0 before any calls to erase. Prior to anything being erased from the set, it's empty?!
My theory at this point is that this has to do with the order in which the objects are destructed as the program terminates. Perhaps the static _instances is being freed before the destructor for MyClass is called.
I was hoping someone would be able to shed some light on this, and confirm whether or not that's what's happening.
My workaround now is to check to see if _instances.size() is 0 before attempting to erase. Is this safe? If not, what else can I do?
If it matters, I'm using MSVC. Here's an executable example.

Answer 1

Here's what happens. That global variable of type InstanceContainer is constructed first, before main is entered. The function-static variable _instances is created later, when Instances() is called for the first time.
At program shutdown, destructors for these objects are called in the reverse order of construction. Therefore, _instances is destroyed first, and then InstanceContainer, which in turn destroys its vector of shared pointers, which in turn run ~MyClass on all objects still in the vector, which in turn call _instances.erase() on already-destroyed _instances. Whereupon your program exhibits undefined behavior by way of accessing an object whose lifetime has ended.
There are several ways you could work around this. One, you could ensure that InstanceContainer::instances is empty before main returns. No idea how feasible this is, as you've never explained what role InstanceContainer plays in your design.
Two, you could allocate _instances on the heap, and just leak it:
static std::unordered_set<MyClass*>& Instances() {
static auto* _instances = new std::unordered_set<MyClass*>;
return *_instances;
}
This will keep it alive through the destruction of global objects.
Three, you could put something like this before the definition of InstanceContainer global variable:
static int dummy = (MyClass::Instances(), 0);
This will ensure that _instances is created earlier, and therefore destroyed later.