The virtual destructor has the same purpose as a virtual function. At runtime looking at the type of object referred by a pointer or reference it is decided which destructor to call -- the destructor of the base class or the destructor of the derived class.

For example suppose B is a base class and D is a class derived from B and suppose both classes have declared their destrcutor as virtual. Suppose a pointer B *ptr is initialized as follows:

B *ptr new D();

Now the ptr is of type B* but points to an object of D. So when this object is freed or goes out of scope D's destructor will be called since the destructors have been declared as virtual.

Your understanding made things simpler.

thanx nitin gupta

is there any real time example towords this virtual destructor. please send me.

really i got the whole concept of virtual destructor.

A very good explaination.

Thx.

A difference between a destructor (of course also the constructor) and other member functions is that if a regular member function has a body at the derived class only the version at Derived class gets executed. Whereas in case of destructors both derived as well as base class versions get executed.

Now turning our attention to why a destructor has to be virtual the reason is that we programmers are very smart. We'll do days and nights of work to inherit and extend the functionality of an existing class which is being used and say that we don't want to change the implementation/interface just for the sake of a new entrant. Let me explain this with an example.

Try executing this code you'll see the difference. To our observation the constructors are getting called in the proper order. But to the dread of a programmer of a large project the destructor of the derived class was not called at all.

This is where the virtual mechanism comes into our rescue. By making the Base class Destructor virtual both the destructors will be called in order. The following is the corrected sample.

#include <iostream.h>
class Base
{
public:
Base(){ cout<<"Constructor: Base"<<endl;}
virtual ~Base(){ cout<<"Destructor : Base"<<endl;}
};
class Derived: public Base
{
//Doing a lot of jobs by extending the functionality
public:
Derived(){ cout<<"Constructor: Derived"<<endl;}
~Derived(){ cout<<"Destructor : Derived"<<endl;}
};
void main()
{
Base *Var new Derived();
delete Var;
}

Note:
There is one more point to be noted regarding virtual destructor. We can't declare pure virtual destructor. Even if a virtual destructor is declared as pure it will have to implement an empty body (at least) for the destructor.

We can declare pure virtual destructor but need to specify its body.
Class Base
{
~Base() 0;
}

Base::~Base(){}

Pure virtual destructor does the same thing which other virtual functions do makes Base class abstract.
I didn't find any other reason to make virtual destructor pure....
does any body knows???

regards
Vineet