Calling virtual function from destructor of an inner class

Question

I have a set up that looks like this

class A
{
    virtual void doSomething() = 0;
    extern "C" A* getSingleton(); 

    class B {
        B() { getSingleton()->doSomething(); }
        ~B() { getSingleton()->doSomething(); }
    };
};

class C : public A
{
    static A a;
    extern "C" A* getSingleton() { return &C::a; }
    void doSomething() { //things }
    // also has a container of Bs that will be added to and removed from regularly
}

Which crashes with a '__cxa_pure_virtual' during the destructor, but not the constructor. C::a is defined correctly in a different file omitted for brevity

I have read that calling virtual functions from ctors/dtors is usually a bad idea, however in this case it will make the usage of B nicer so am interested in getting it to work safely. Can anyone explain why B's ctor manages to do this dodgy action but the dtor can't, and then how can I rework this properly?

Answer 1

The problem is the order of execution.

In C++ objects are created from top to down. What does it mean?

When you have a class X and Y. The class Y inherit from X.

X = "father" Y = "son"

When you instantiate an object of type Y, and put some print on the constructor and destructor, you will see that first the constructor of X is called, then the constructor of class Y.

The destruction is (of course) in inverted way. First is called the destructor of Y, then the destructor of class X.

Knowing that, then we look to the OO problem that you have: Calling a virtual pure method in the destructor of the X class (father). When the destructor of X class is executed, the Y (son) object doesn't exist anymore.

So: how can the X object find the virtual pure method, that should be implement in the inherited class/object?