当在c++中覆盖一个类(使用虚析构函数)时,我在继承类上再次实现了虚析构函数,但我需要调用基析构函数吗?

如果是这样的话,我想应该是这样的……

MyChildClass::~MyChildClass() // virtual in header
{
    // Call to base destructor...
    this->MyBaseClass::~MyBaseClass();

    // Some destructing specific to MyChildClass
}

我说的对吗?


当前回答

不。它会被自动调用。

其他回答

不,析构函数是按照构造的相反顺序自动调用的。(基类最后)。不要调用基类析构函数。

不。它会被自动调用。

不。与其他虚方法不同的是,在其他虚方法中,您需要显式地从Derived调用Base方法来“链接”调用,编译器会生成代码,以调用析构函数的构造函数的相反顺序调用析构函数。

c++中的析构函数只有在基类析构函数声明为虚时才会自动按其构造的顺序(先派生后基)调用。

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

示例:没有虚析构函数

#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

示例:使用基本虚析构函数

#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

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

参考:虚析构函数

其他人说了什么,但还要注意,您不必在派生类中声明析构函数虚值。一旦将析构函数声明为虚函数,就像在基类中所做的那样,所有派生析构函数都将是虚函数,无论是否这样声明。换句话说:

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

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

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