Thread: Trouble understanding virtual destructor example?

I'm studying for my upcoming final and I can't understand this particular problem regarding virtual destructors:

Code:

#include <iostream>
using namespace std; 

class A
{
   public:

          A(int n =2) 
            :x(n)  
          {
               cout "A constructor " << endl; 
          }
          virtual void Add(int n)
          {

             x+=n;
          }

          virtual ~A()
          {

              cout << x << endl; 
              cout << "A destructor " << endl; 
          }

          protected:
                int x; 

};
          
Class B: public A
{

    public:
           B(int n)
              :A(n)  
           {

                y= 0; 
                z=0; 
                cout << "B constructor" << endl; 
            }

           void Add(int n)
           {

               x= 0; 
               y +=n; 
               z = 1; 
            }

            ~B()
            {

                  cout << "B destructor " << endl; 
                  std::cout << y << z; 
             } 
             private:

                 int y; 
                 int z;
};


int main()
{

       int c =1; 
       B *b = new B(5); 
       A *a
       a = b; 
       a -> Add(c); 
       delete a; 
       std::cout << std::endl; 
       return 0; 
}

and the out put is:

A constructor
B constructor
B destructor
110
A destructor

I think I understand most of it, but there are certain things that i'm a little unsure of:

A constructor
B constructor

reason: b pointer is allocated and points to derived object, meaning A constructor is called, followed by inherited B constructor


B destructor

reason: called because we deleted the a pointer which pointed to the derived object, so it utilizes it's derived class B destructor. The a->add(c), sends c to the derived B class add function, which sets x=0, y=1 and z =1. This makes the output 110 based on how the variables print in the B class destructor.


here's where i'm tripping up:

A constructor

reason: Is this because right after the a pointer is deallocated, the base class destructor activates, and then prints that out? What about the b pointer that ISNT explicitly deleted when the main function terminates, shouldn't this also print out Another:

B destructor
A destructor


for the b pointer?

Sorry If this is fairly long.

When you create a derived object, you must also create its base objects. So when you create a B, you must also create its A part. Therefore, A's constructor is called first and then B's.
When you destroy an object, the reverse must be done. First you must destroy the B part and then the A part. While B is technically an A, the A part of B and the B part of B are separate parts of the object. The B class does not know how to construct an A. A's constructor does. Similarly, class A does not know how to construct a B. B's constructor knows this. It's the same story for the destructors. Since B does not know how to destroy the A part, it calls A's destructor to finish that part. The compiler calls B's destructor and B's destructor will then call A's destructor.

As for if you don't delete the pointer... then no destructor will be called at all. Destructors are only called when an object is destroyed. If you don't delete what you new, then it will never be destroyed (only the pointer that points to it).

Originally Posted by garmbrust

Yes I think it's starting to make sense now. So basically you aren't just deleting the pointer, but also the object to which it points when you delete it? Meaning it deletes the B portion first, and then the a portion?

It works this way because of the virtual functions. The virtual interface is polymorphism.

Originally Posted by garmbrust

What would happen if we were to hypothetically delete b, would that produce the same result too since it points to the same object..?

That's right, the same thing happens. The difference is that you aren't using polymorphism anymore, since you are just directly calling B's destructor.