Q:

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

A:

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.

