在多级继承中调用析构函数（c ++）

Question

I coded the following classes in order to test the multi-level inheritance concept. There is a point that I didn't really understand when I was trying to test the calls to constructors and destructors.

---

#include <iostream>

using namespace std;

class X{

    public:
        X(){cout <<"Construct X " << endl;};
        virtual ~X(){cout <<"Destruct X " << endl;};
        virtual void print() const = 0;
};

class Y: public X{
    public:
        Y(){cout <<"construct Y " << endl;};
        ~Y(){cout <<"Destruct Y " << endl;};
        void print() const{
            cout <<"print Y" << endl;
        };
};

class Z: public Y{
    public:
        Z(){cout <<"Construct Z" << endl; };
        ~Z(){cout <<"Destruct Z " << endl; };
        void print() const{
            cout <<" Print Z" << endl;
        };
};

int main()
{
    Y y;
    //Why isn't Y being destructed in here
    Z z;
    return 0;
}

---

Output

The output is the following. I understood that we start from the base class . So in Y y; first the constructor of X is called, then Y . In Z z; first the construct of X is called, then Y and finally Z .

Construct X
construct Y
Construct X
construct Y
Construct Z
Destruct Z
Destruct Y
Destruct X
Destruct Y
Destruct X

---

Question

• Why isn't the destructor for Y being called right after Y y; . Why should we wait till Z is constructed then call the destructors. Meaning why doesn't the output look like that:

   Construct X construct Y Destruct Y Destruct X Construct X construct Y Construct Z Destruct Z Destruct Y Destruct X 

Answer 1

Inheritance is a red herring here. It's not relevant.

y and z have automatic storage duration and are required, in this case, to stay in scope until the closing brace of the function.

And z will be destructed before y . (Automatic variables go out of scope in the reverse order in which they were created, all other things being equal.)

Answer 2

This is unrelated to inheritance. Variables declared in block scope are destroyed when that block is left, ie a return statement is taken or the final } is reached or an exception is thrown.

Answer 3

The objects exist at the end of their scope, and the objects get destroyed in reverse order of their construction.

y is constructed first, then z . So, when their mutual scope's end is reached, z gets destroyed first, then y .

You were expecting the objects to be destroyed in the same order they were constructed, but they actually get destroyed in reverse order of construction.

Similarly, when an object gets constructed, its base class is constructed first, then the derived class. When the object gets destroyed, the derived class gets destroyed first, then the base class.