我需要显式调用基本虚拟析构函数吗？

不，析构函数会以与构造相反的顺序自动调用。 （最后是基类）。不要调用基类析构函数。

---

不，您不需要调用基析构函数，派生析构函数始终为您调用基析构函数。 Please see my related answer here for order of destruction。

要了解为什么要在基类中使用虚拟析构函数，请查看以下代码：

class B
{
public:
    virtual ~B()
    {
        cout<<"B destructor"<<endl;
    }
};


class D : public B
{
public:
    virtual ~D()
    {
        cout<<"D destructor"<<endl;
    }
};

当你这样做时：

B *pD = new D();
delete pD;

然后，如果您在 B 中没有虚拟析构函数，则只会调用 ~B()。但是因为你有一个虚拟析构函数，所以首先调用~D()，然后调用~B()。

---

其他人所说的，但还要注意，您不必在派生类中声明析构函数 virtual 。一旦你声明了一个虚拟的析构函数，就像你在基类中所做的那样，所有派生的析构函数都将是虚拟的，无论你是否声明它们。换句话说：

struct A {
   virtual ~A() {}
};

struct B : public A {
   virtual ~B() {}   // this is virtual
};

struct C : public A {
   ~C() {}          // this is virtual too
};

---

C++ 中的析构函数自动按其构造顺序调用（先派生然后基）仅在声明基类析构函数时virtual。

如果不是，则在删除对象时仅调用基类析构函数。

示例：没有虚拟析构函数

#include <iostream>

using namespace std;

class Base{
public:
  Base(){
    cout << "Base Constructor \n";
  }

  ~Base(){
    cout << "Base Destructor \n";
  }

};

class Derived: public Base{
public:
  int *n;
  Derived(){
    cout << "Derived Constructor \n";
    n = new int(10);
  }

  void display(){
    cout<< "Value: "<< *n << endl;
  }

  ~Derived(){
    cout << "Derived Destructor \n";
  }
};

int main() {

 Base *obj = new Derived();  //Derived object with base pointer
 delete(obj);   //Deleting object
 return 0;

}

输出

Base Constructor
Derived Constructor
Base Destructor

示例：使用 Base 虚拟析构函数

#include <iostream>

using namespace std;

class Base{
public:
  Base(){
    cout << "Base Constructor \n";
  }

  //virtual destructor
  virtual ~Base(){
    cout << "Base Destructor \n";
  }

};

class Derived: public Base{
public:
  int *n;
  Derived(){
    cout << "Derived Constructor \n";
    n = new int(10);
  }

  void display(){
    cout<< "Value: "<< *n << endl;
  }

  ~Derived(){
    cout << "Derived Destructor \n";
    delete(n);  //deleting the memory used by pointer
  }
};

int main() {

 Base *obj = new Derived();  //Derived object with base pointer
 delete(obj);   //Deleting object
 return 0;

}

输出

Base Constructor
Derived Constructor
Derived Destructor
Base Destructor

建议将基类析构函数声明为 virtual，否则会导致未定义的行为。

参考：Virtual Destructor

---

不，你永远不会调用基类析构函数，它总是像其他人指出的那样被自动调用，但这里有结果的概念证明：

class base {
public:
    base()  { cout << __FUNCTION__ << endl; }
    ~base() { cout << __FUNCTION__ << endl; }
};

class derived : public base {
public:
    derived() { cout << __FUNCTION__ << endl; }
    ~derived() { cout << __FUNCTION__ << endl; } // adding call to base::~base() here results in double call to base destructor
};


int main()
{
    cout << "case 1, declared as local variable on stack" << endl << endl;
    {
        derived d1;
    }

    cout << endl << endl;

    cout << "case 2, created using new, assigned to derive class" << endl << endl;
    derived * d2 = new derived;
    delete d2;

    cout << endl << endl;

    cout << "case 3, created with new, assigned to base class" << endl << endl;
    base * d3 = new derived;
    delete d3;

    cout << endl;

    return 0;
}

输出是：

case 1, declared as local variable on stack

base::base
derived::derived
derived::~derived
base::~base


case 2, created using new, assigned to derive class

base::base
derived::derived
derived::~derived
base::~base


case 3, created with new, assigned to base class

base::base
derived::derived
base::~base

Press any key to continue . . .

如果您将基类析构函数设置为虚拟的，那么情况 3 的结果将与情况 1 和 2 相同。

---

不。与其他虚拟方法不同，您会从 Derived 显式调用 Base 方法以“链接”调用，编译器生成代码以按照调用构造函数的相反顺序调用析构函数。

---

不，它是自动调用的。

---