virtual destructor的使用

virtual方法(virtual function)：

If a method is virtual, then calling the method on an object always invokes the method as implemented by the most heavily derived class. If the method is not virtual, then the implementation corresponding to the compile-time type of the object pointer.

For instance:

class Sample {
public:
    void f();
    virtual void vf();
};

class Derived : public Sample {
public:
    void f();
    void vf();
}

void function()
{
    Derived d;
    Sample* p = &d;
    p->f();
    p->vf();
}

The call to p->f() will result in a call toSample::f because p is a pointer to a Sample. The actual object is of typeDerived, but the pointer is merely a pointer to a Sample. The pointer type is used becausef is not virtual.

On the other hand, the call to The call to p->vf() will result in a call to Derived::vf, the most heavily derived type, becausevf is virtual.

Okay, you knew that. 

virtual析构函数(virtual destructor)：

Virtual destructors work exactly the same way. It's just that you rarely invoke the destructor explicitly. Rather, it's invoked when an automatic object goes out of scope or when youdelete the object.

void function()
{
    Sample* p = new Derived;
    delete p;
}

Since Sample does not have a virtual destructor, thedelete p invokes the destructor of the class of the pointer (Sample::~Sample()), rather than the destructor of the most derived type (Derived::~Derived()). And as you can see, this is the wrong thing to do in the above scenario.

Armed with this information, you can now answer the question.

A class must have a virtual destructor if it meets both of the following criteria:

• You do a delete p.
• It is possible that p actually points to a derived class.

Some people say that you need a virtual destructor if and only if you have a virtual method. This is wrong in both directions.

Example of a case where a class has no virtual methods but still needs a virtual destructor:

class Sample { };
class Derived : public Sample
{
    CComPtr<IStream> m_p;
public:
    Derived() { CreateStreamOnHGlobal(NULL, TRUE, &m_p); }
};

Sample *p = new Derived;
delete p;

The delete p will invokeSample::~Sample instead of Derived::~Derived, resulting in a leak of the streamm_p. 

And here's an example of a case where a class has virtual methods but does not require a virtual destructor.

class Sample { public: virtual void vf(); }
class Derived : public Sample { public: virtual void vf(); }

Derived *p = new Derived;
delete p;

Since the object deletion occurs from the pointer type that matches the type of the actual object, the correct destructor will be invoked. This pattern happens often in COM objects, which expose several virtual methods corresponding to its interfaces, but where the object itself is destroyed by its own implementation and not from a base calss pointer. (Notice that no COM interfaces contain virtual destructors.)

The problem with knowing when to make your destructor virtual or not is that you have to know how people will be using your class. If C++ had a "sealed" keyword, then the rule would be simpler: If you do a "delete p" where p is a pointer to an unsealed class, then that class needs have a virtual destructor. (The imaginary "sealed" keyword makes it explicit when a class can act as the base class for another class.)