我建议这样做：如果类或结构不是最终的，那么应该为其定义虚拟析构函数。

我知道这看起来像是一种过度警惕的过度杀戮，成为一种经验法则。但是，这是确保从类派生的人在使用基指针删除时不会使用UB的唯一方法。

Scott Meyers在下面引用的有效C++中的建议很好，但不足以确定。

如果一个类有任何虚函数，它应该有一个虚函数析构函数，并且类是否设计为基类设计用于多态性的不应声明虚拟析构函数。

例如，在下面的程序中，基类B没有任何虚拟函数，因此根据Meyer的说法，您不需要编写虚拟析构函数。然而，如果您没有以下UB：

#include <iostream>

struct A
{
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }
};

struct B
{
};

struct C : public B
{
    A a;
};

int main(int argc, char *argv[])
{
    B *b = new C;
    delete b; // UB, and won't print "A::~A()"
    return 0;
}

我认为讨论“未定义”行为，或者至少讨论在通过没有虚拟析构函数的基类（/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。一种方法是添加一个虚拟析构函数，您可能无论如何都希望它能正确地清理资源。

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

 #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

将所有析构函数都设为虚拟，除非你有充分的理由不这样做。

否则会发生这样的邪恶：

假设您有一个包含Apple和Orange对象的Fruit指针数组。

从Fruit对象集合中删除时，除非~Fruit（）是虚拟的，否则无法调用~Apple（）和~Orange（）。

正确完成示例：

#include <iostream>
using namespace std;
struct Fruit { // good
  virtual ~Fruit() { cout << "peel or core should have been tossed" << endl; } 
};
struct Apple:  Fruit { virtual ~Apple()  {cout << "toss core" << endl; } };
struct Orange: Fruit { virtual ~Orange() {cout << "toss peel" << endl; } };

int main() { 
  Fruit *basket[]={ new Apple(), new Orange() };
  for (auto fruit: basket) delete fruit;
};

正品产出量

toss core
peel or core should have been tossed
toss peel
peel or core should have been tossed

错误示例：

#include <iostream>
using namespace std;
struct Fruit { // bad 
  ~Fruit() { cout << "peel or core should have been tossed" << endl; } 
};
struct Apple:  Fruit { virtual ~Apple()  {cout << "toss core" << endl; } };
struct Orange: Fruit { virtual ~Orange() {cout << "toss peel" << endl; } };

int main() { 
  Fruit *basket[]={ new Apple(), new Orange() };
  for (auto fruit: basket) delete fruit;
};

不良输出

peel or core should have been tossed
peel or core should have been tossed

（注意：为了简洁起见，我使用了struct，通常使用class并指定public）

我建议这样做：如果类或结构不是最终的，那么应该为其定义虚拟析构函数。

我知道这看起来像是一种过度警惕的过度杀戮，成为一种经验法则。但是，这是确保从类派生的人在使用基指针删除时不会使用UB的唯一方法。

Scott Meyers在下面引用的有效C++中的建议很好，但不足以确定。

如果一个类有任何虚函数，它应该有一个虚函数析构函数，并且类是否设计为基类设计用于多态性的不应声明虚拟析构函数。

例如，在下面的程序中，基类B没有任何虚拟函数，因此根据Meyer的说法，您不需要编写虚拟析构函数。然而，如果您没有以下UB：

#include <iostream>

struct A
{
    ~A()
    {
        std::cout << "A::~A()" << std::endl;
    }
};

struct B
{
};

struct C : public B
{
    A a;
};

int main(int argc, char *argv[])
{
    B *b = new C;
    delete b; // UB, and won't print "A::~A()"
    return 0;
}

通过指向基类的指针调用析构函数

struct Base {
  virtual void f() {}
  virtual ~Base() {}
};

struct Derived : Base {
  void f() override {}
  ~Derived() override {}
};

Base* base = new Derived;
base->f(); // calls Derived::f
base->~Base(); // calls Derived::~Derived

虚拟析构函数调用与任何其他虚拟函数调用都没有区别。

对于base->f（），调用将被分派到Derived:：f（）中，对于base->~base（）也是如此-它的重写函数-将调用Derived:：~Derived（）。

间接调用析构函数时也会发生同样的情况，例如delete base；。delete语句将调用base->~base（），该函数将被分派到Derived:：~Derived（）。

具有非虚拟析构函数的抽象类

若您不打算通过指向其基类的指针删除对象，那个么就不需要使用虚拟析构函数。只需保护它，使其不会被意外调用：

// library.hpp

struct Base {
  virtual void f() = 0;

protected:
  ~Base() = default;
};

void CallsF(Base& base);
// CallsF is not going to own "base" (i.e. call "delete &base;").
// It will only call Base::f() so it doesn't need to access Base::~Base.

//-------------------
// application.cpp

struct Derived : Base {
  void f() override { ... }
};

int main() {
  Derived derived;
  CallsF(derived);
  // No need for virtual destructor here as well.
}