如果使用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

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

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.

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

我认为这里的大多数答案都没有抓住重点，除了公认的答案，这是一件好事。然而，让我再补充一个对这个问题有不同看法的问题：如果你想多态地删除这个类的实例，你需要一个虚拟析构函数。

这种方式回避了这个问题，所以让我详细说明一下：正如许多人所指出的，如果调用delete base_ptr并且析构函数不是虚拟的，就会出现不希望的行为。然而，有几个假设需要明确：

如果您的类不是基类，那么希望您不会编写这样的代码。在本例中，我不是指手动内存管理，它本身就很糟糕，而是从这个类中公开派生出来的。不应继承未设计为基类的类，例如std:：string。C++可以让你射自己的脚。这是你的错，而不是基类没有虚拟析构函数。如果析构函数不可访问（受保护的或私有的），则此代码不会编译，因此不会出现不希望的行为。有一个受保护的析构函数是有用的，特别是对于mixin，但对于接口（在较小程度上）也是有用的。除非您实际使用了虚拟函数，否则您不希望产生虚拟函数的开销。相反，使析构函数受到保护可以防止不期望的行为，但不会限制您的行为。如果您实际上编写了一个应该派生自的类，那么通常都会有虚拟函数。作为它们的用户，通常只能通过指向基类的指针来使用它们。当这种使用包括处理它们时，它也需要是多态的。当您应该将析构函数设为虚拟时，就会出现这种情况。

对于这个主题的一个类似的不同观点，也可以阅读“什么时候不应该使用虚拟析构函数？”？

当您希望不同的析构函数在通过基类指针删除对象时遵循正确的顺序时，析构函数的虚拟关键字是必需的。例如：

Base *myObj = new Derived();
// Some code which is using myObj object
myObj->fun();
//Now delete the object
delete myObj ; 

如果基类析构函数是虚拟的，那么对象将按顺序被析构函数（首先是派生对象，然后是基）。如果基类析构函数不是虚拟的，那么只有基类对象会被删除（因为指针是基类“base*myObj”）。因此派生对象将存在内存泄漏。

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

我知道这看起来像是一种过度警惕的过度杀戮，成为一种经验法则。但是，这是确保从类派生的人在使用基指针删除时不会使用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.
}