we make destructure as virtual because when we derived a 
class from base class then destructor called from derived 
to base so for this happening correctly we haveto make base 
class destructor as avirtual.

Vitual destructor is used 

(1) whenever the base class object pointer points to 
derived class object,and is being created using new.
i.e class base - base class
in main - base bptr;
class derived - derived class
in main - bptr = new derived();

Then whenever we use "delete bptr" at runtime always the 
memory of bptr is freed but not derived because here the 
pointer is of type base and not of derived.

Note: The destructor that gets invoked is the one that 
associated with the type of the object.

Simple rule of thumb: Make your destructor virtual if your 
class has any virtual functions.

Example: 
#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;
}

what chandra said is correct.but it is not 100% correct.for 
that answer i want to add one point.

whenever 
1)there is a pointer in the base class and we allocated 
with the help of new in base class and anthoer pointer in 
derived class and agin we allocated with the help of new.
2)whenever the base class object pointer points to 
derived class object,and is being created using new.
i.e class base - base class
in main - base bptr;
class derived - derived class
in main - bptr = new derived();

this will be illustrated with an example given below


#include <iostream.h>
class Base
{      protected:
           int *ptr;
       public:
          Base()
          {     ptr = new  int[10];
               cout<<"Constructor: Base"<<endl;
          }
          virtual ~Base()
          { 
                cout<<"Destructor : Base"<<endl;
                delete []ptr;
           }
};
class Derived: public Base
{
       protected:
            int *ptr1;
       public:
           Derived()
           {          
                      ptr1=new int[10]; 
                      cout<<"Constructor: Derived"<<endl;
           }
           ~Derived()
           { 
                delete []ptr1;    
                cout<<"Destructor : Derived"<<endl;
           }
};
void main()
{
        Base *Var = new Derived;
        delete Var;
}

if we are not placing virtual in base  class, only base 
class destructor will be called because "var is of type 
Base".so,
if we are not placing virtual compiler will see only "type 
of the pointer,not the object which it is holding".so,if we 
place virtual it will see the object it is holding.

now memory allocated for ptr,ptr1 in heap was destroyed by 
destructors of the  respective class.