简单地说，当您删除指向派生类对象的基类指针时，虚拟析构函数将以正确的顺序析构函数资源。

 #include<iostream>
 using namespace std;
 class B{
    public:
       B(){
          cout<<"B()\n";
       }
       virtual ~B(){ 
          cout<<"~B()\n";
       }
 };
 class D: public B{
    public:
       D(){
          cout<<"D()\n";
       }
       ~D(){
          cout<<"~D()\n";
       }
 };
 int main(){
    B *b = new D();
    delete b;
    return 0;
 }

OUTPUT:
B()
D()
~D()
~B()

==============
If you don't give ~B()  as virtual. then output would be 
B()
D()
~B()
where destruction of ~D() is not done which leads to leak

简单地说，当您删除指向派生类对象的基类指针时，虚拟析构函数将以正确的顺序析构函数资源。

 #include<iostream>
 using namespace std;
 class B{
    public:
       B(){
          cout<<"B()\n";
       }
       virtual ~B(){ 
          cout<<"~B()\n";
       }
 };
 class D: public B{
    public:
       D(){
          cout<<"D()\n";
       }
       ~D(){
          cout<<"~D()\n";
       }
 };
 int main(){
    B *b = new D();
    delete b;
    return 0;
 }

OUTPUT:
B()
D()
~D()
~B()

==============
If you don't give ~B()  as virtual. then output would be 
B()
D()
~B()
where destruction of ~D() is not done which leads to leak

在多态基类中声明虚拟的析构函数。这是Scott Meyers的有效C++中的第7项。Meyers接着总结道，如果一个类有任何虚拟函数，那么它应该有一个虚拟析构函数，而不是设计为基类或不是设计为多态使用的类不应该声明虚拟析构器。

我认为讨论“未定义”行为，或者至少讨论在通过没有虚拟析构函数的基类（/struct）删除时可能发生的“崩溃”未定义行为，或者更准确地说，没有vtable，是有益的。下面的代码列出了一些简单的结构（类也是如此）。

#include <iostream>
using namespace std;

struct a
{
    ~a() {}

    unsigned long long i;
};

struct b : a
{
    ~b() {}

    unsigned long long j;
};

struct c : b
{
    ~c() {}

    virtual void m3() {}

    unsigned long long k;
};

struct d : c
{
    ~d() {}

    virtual void m4() {}

    unsigned long long l;
};

int main()
{
    cout << "sizeof(a): " << sizeof(a) << endl;
    cout << "sizeof(b): " << sizeof(b) << endl;
    cout << "sizeof(c): " << sizeof(c) << endl;
    cout << "sizeof(d): " << sizeof(d) << endl;

    // No issue.

    a* a1 = new a();
    cout << "a1: " << a1 << endl;
    delete a1;

    // No issue.

    b* b1 = new b();
    cout << "b1: " << b1 << endl;
    cout << "(a*) b1: " << (a*) b1 << endl;
    delete b1;

    // No issue.

    c* c1 = new c();
    cout << "c1: " << c1 << endl;
    cout << "(b*) c1: " << (b*) c1 << endl;
    cout << "(a*) c1: " << (a*) c1 << endl;
    delete c1;

    // No issue.

    d* d1 = new d();
    cout << "d1: " << d1 << endl;
    cout << "(c*) d1: " << (c*) d1 << endl;
    cout << "(b*) d1: " << (b*) d1 << endl;
    cout << "(a*) d1: " << (a*) d1 << endl;
    delete d1;

    // Doesn't crash, but may not produce the results you want.

    c1 = (c*) new d();
    delete c1;

    // Crashes due to passing an invalid address to the method which
    // frees the memory.

    d1 = new d();
    b1 = (b*) d1;
    cout << "d1: " << d1 << endl;
    cout << "b1: " << b1 << endl;
    delete b1;  

/*

    // This is similar to what's happening above in the "crash" case.

    char* buf = new char[32];
    cout << "buf: " << (void*) buf << endl;
    buf += 8;
    cout << "buf after adding 8: " << (void*) buf << endl;
    delete buf;
*/
}

我并不是建议你是否需要虚拟析构函数，尽管我认为一般来说，拥有它们是一个很好的做法。我只是指出了如果基类（/struct）没有vtable，而派生类（/struck）有vtable，并且通过基类（/ststruct）指针删除对象，那么可能会导致崩溃的原因。在这种情况下，传递给堆的空闲例程的地址是无效的，因此是崩溃的原因。

如果运行上述代码，您将清楚地看到问题发生的时间。当基类（/struct）的this指针与派生类（/struct）的this指示器不同时，您将遇到此问题。在上面的示例中，结构a和b没有vtables。结构c和d确实有vtables。因此，指向c或d对象实例的a或b指针将被修复以说明vtable。如果传递此a或b指针进行删除，则会由于地址对堆的空闲例程无效而崩溃。

如果计划从基类指针中删除具有vtable的派生实例，则需要确保基类具有vtable。一种方法是添加一个虚拟析构函数，您可能无论如何都希望它能正确地清理资源。

我认为这个问题的核心是关于虚拟方法和多态性，而不是具体的析构函数。下面是一个更清晰的例子：

class A
{
public:
    A() {}
    virtual void foo()
    {
        cout << "This is A." << endl;
    }
};

class B : public A
{
public:
    B() {}
    void foo()
    {
        cout << "This is B." << endl;
    }
};

int main(int argc, char* argv[])
{
    A *a = new B();
    a->foo();
    if(a != NULL)
    delete a;
    return 0;
}

将打印出：

This is B.

如果没有虚拟，它将打印出：

This is A.

现在您应该了解何时使用虚拟析构函数。

如果使用shared_ptr（仅shared_ptl，而不是unique_ptr），则不必将基类析构函数设为虚拟：

#include <iostream>
#include <memory>

using namespace std;

class Base
{
public:
    Base(){
        cout << "Base Constructor Called\n";
    }
    ~Base(){ // not virtual
        cout << "Base Destructor called\n";
    }
};

class Derived: public Base
{
public:
    Derived(){
        cout << "Derived constructor called\n";
    }
    ~Derived(){
        cout << "Derived destructor called\n";
    }
};

int main()
{
    shared_ptr<Base> b(new Derived());
}

输出：

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