When to use virtual destructors?

I have a solid understanding of most OO theory but the one thing that confuses me a lot is virtual destructors.

I thought that the destructor always gets called no matter what and for every object in the chain.

When are you meant to make them virtual and why?

---

Virtual destructors are useful when you can delete an instance of a derived class through a pointer to base class:

class Base 
{
    // some virtual methods
};

class Derived : public Base
{
    ~Derived()
    {
        // Do some important cleanup
    }
};

Here, you'll notice that I didn't declare Base's destructor to be virtual . Now, let's have a look at the following snippet:

Base *b = new Derived();
// use b
delete b; // Here's the problem!

Since Base's destructor is not virtual and b is a Base* pointing to a Derived object, delete b has undefined behaviour:

[In delete b ], if the static type of the object to be deleted is different from its dynamic type, the static type shall be a base class of the dynamic type of the object to be deleted and the static type shall have a virtual destructor or the behavior is undefined .

In most implementations, the call to the destructor will be resolved like any non-virtual code, meaning that the destructor of the base class will be called but not the one of the derived class, resulting in a resources leak.

To sum up, always make base classes' destructors virtual when they're meant to be manipulated polymorphically.

If you want to prevent the deletion of an instance through a base class pointer, you can make the base class destructor protected and nonvirtual; by doing so, the compiler won't let you call delete on a base class pointer.

You can learn more about virtuality and virtual base class destructor in this article from Herb Sutter.

---

Declare destructors virtual in polymorphic base classes. This is Item 7 in Scott Meyers' Effective C++. Meyers goes on to summarize that if a class has any virtual function, it should have a virtual destructor, and that classes not designed to be base classes or not designed to be used polymorphically should not declare virtual destructors.

---

A virtual constructor is not possible but virtual destructor is possible. Let us experiment....

#include <iostream>

using namespace std;

class Base
{
public:
    Base(){
        cout << "Base Constructor Calledn";
    }
    ~Base(){
        cout << "Base Destructor calledn";
    }
};

class Derived1: public Base
{
public:
    Derived1(){
        cout << "Derived constructor calledn";
    }
    ~Derived1(){
        cout << "Derived destructor calledn";
    }
};

int main()
{
    Base *b = new Derived1();
    delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

The construction of derived object follow the construction rule but when we delete the "b" pointer(base pointer) we have found that only the base destructor is call.But this must not be happened. To do the appropriate thing we have to make the base destructor virtual. Now let see what happen in the following:

#include <iostream>

using namespace std;

class Base
{ 
public:
    Base(){
        cout << "Base Constructor Calledn";
    }
    virtual ~Base(){
        cout << "Base Destructor calledn";
    }
};

class Derived1: public Base
{
public:
    Derived1(){
        cout << "Derived constructor calledn";
    }
    ~Derived1(){
        cout << "Derived destructor calledn";
    }
};

int main()
{
    Base *b = new Derived1();
    delete b;
}

The output changed as following:

Base Constructor Called
Derived constructor called
Derived destructor called
Base Destructor called

So the destruction of base pointer(which take an allocation on derived object!) follow the destruction rule ie first the derived then the base. On the other hand for constructor there are nothing like virtual constructor.

链接地址: http://www.djcxy.com/p/20780.html

上一篇: 为什么'这个'是一个指针而不是一个参考？

下一篇: 何时使用虚拟析构函数？