CODEWITHSUNDEEP
c++inheritancevirtual-destructor
nagaradderKantesh
nagaradderKantesh

Reputation: 1690

Destructor concept in c++

please go through my below code:

#include "stdafx.h"
#include <iostream>
#include <conio.h>
using namespace std;

class ClassA
{
    protected:
    int width, height;

    public:
  void set_values(int x, int y)
  {
      width = x;
      height = y;
  }
  virtual int area()
  {
      return 100;
  }
  ~ClassA()
  {
      cout << "base class destructor called" << endl;

  }
};

class ClassB : public ClassA
{
    public :
int area()
{
    return (width * height);
}
~ClassB()
{
    cout << "derived class destructor called" << endl;
}
};
int main()
{
  ClassA *Ptr = new ClassB;
  Ptr->set_values(10, 20);
  cout << Ptr->area() << endl;
  delete Ptr;
     return 0;
}

In the above code the pointer contain the address of derived class object so it should call derived class destructor along with base class destructor when i delete the pointer,but why it is calling only base class destructor. if i made base class destructor as virtual then it is calling both derived class and base class destructor why?. and in virtual functions case both the base and derived class has the same function name so compiler resolve the one which is most derived in the derived class but here the destructor won't have same name then how the compiler resolves which one it has to call during run time.please explain me how

Upvotes: 0

Views: 138

Answers (4)

Andy Prowl
Andy Prowl

Reputation: 126522

You should make the destructor of your base class virtual in order for polymorphic destruction to work properly:

class ClassA
{
    // ...
    virtual ~ClassA()
//  ^^^^^^^
//  Add this!
    {
        cout << "base class destructor called" << endl;
    }
};

If you do not do that, you get Undefined Behavior when doing delete Ptr.

if i made base class destructor as virtual then it is calling both derived class and base class destructor why?

This is part of the regular object destruction sequence. When you destroy an object, the destructor of that object's class gets called first, then the destructors of all the non-static class members of that object (in inverse order of declaration), then the destructors of all its base classes.

Thus, virtual dispatch is correctly performed here (if you make your base class destructor virtual, of course), in the sense that the first destructor that gets invoked is the destructor of the actual run-time type of your object (ClassB). After that, the destructor of the base class ClassA gets invoked as well as part of the normal destruction process.

but here the destructor won't have same name then how the compiler resolves which one it has to call during run time

Destructors are special member functions. Each class can have only one destructor, so their name (which must be identical to the name of the class, with the prepended ~ character) is irrelevant. The compiler knows which function is a destructor.

Upvotes: 3

Nick
Nick

Reputation: 25808

You need to mark your destructors as virtual. Otherwise the compiler doesn't know to call the most-derived destructor.

virtual ~ClassA()
{
    cout << "base class destructor called" << endl;

}

Upvotes: 0

Tony The Lion
Tony The Lion

Reputation: 63250

Because your Base class destructor should be virtual.

Upvotes: 2

Luchian Grigore
Luchian Grigore

Reputation: 258638

That's actually undefined behavior because ~ClassA() is not virtual, so anything can happen.

ClassA *Ptr = new ClassB;
///....
delete Ptr;

Upvotes: 0

Related Questions