C++学习——如何析构派生类

析构派生类

先看一段简单的代码：

#include <iostream>using namespace std;class AA
{
public:AA() {cout << "调用了基类构造" << endl;}virtual void func() {cout << "调用了基类 func()" << endl;}~AA() {cout << "调用了基类析构！" << endl;}};class BB : public AA
{
public:BB() {cout << "调用了子类构造" << endl;}void func() {cout << "调用了子类 func()" << endl;}~BB() {cout << "调用了子类析构！" << endl;}};int main() {// AA aa;BB bb;return 0;
}

编译运行的结果如下：

调用了基类构造
调用了子类构造
调用了子类析构！
调用了基类析构！

修改一下main()函数：

int main() {BB* bb_ptr = new BB;delete bb_ptr;return 0;
}

编译运行的结果与之前一样：

调用了基类构造
调用了子类构造
调用了子类析构！
调用了基类析构！

再修改一下代码，手工调用子类的析构函数：

int main() {BB* bb_ptr = new BB;bb_ptr->~BB();bb_ptr->~BB();bb_ptr->~BB();delete bb_ptr;return 0;
}

编译运行的结果如下：

调用了基类构造
调用了子类构造
调用了子类析构！
调用了基类析构！
调用了子类析构！
调用了基类析构！
调用了子类析构！
调用了基类析构！
调用了子类析构！
调用了基类析构！

可以发现，每次手工调用子类的析构函数，都会调用一次基类的析构函数。
子类的析构函数在执行完成后，会自动调用基类的析构函数。这是C++编译器强制的规定。
继续修改代码，用基类指针指向派生类new出来的对象，代码如下：

int main() {AA* aa_ptr = new BB; // 基类指针指向派生类对象delete aa_ptr; // 基类指针释放派生类对象return 0;
}

编译运行的结果如下：

调用了基类构造
调用了子类构造
调用了基类析构！

用基类指针指向派生类对象是多态的精髓。但用基类指针销毁派生对象时，不能调用派生类的析构函数。在应用开发中，一般会把释放资源的代码写在析构函数中。如果析构函数未调用，会有内存泄漏的风险。
但上面这段代码运行的效果没有调用派生类的析构函数，如果需要调用派生类的虚构函数，则把基类的析构函数声明为虚构函数即可，代码如下：

#include <iostream>using namespace std;class AA
{
public:AA() {cout << "调用了基类构造" << endl;}virtual void func() {cout << "调用了基类 func()" << endl;}// 基类的析构函数是虚函数virtual ~AA() {cout << "调用了基类析构！" << endl;}};class BB : public AA
{
public:BB() {cout << "调用了子类构造" << endl;}void func() {cout << "调用了子类 func()" << endl;}~BB() {cout << "调用了子类析构！" << endl;}};int main() {AA* aa_ptr = new BB; // 基类指针指向派生类对象delete aa_ptr; // 基类指针释放派生类对象return 0;
}

编译运行的结果如下：

调用了基类构造
调用了子类构造
调用了子类析构！
调用了基类析构！

正常情况下，释放堆区内存后，会把指针指向空，防止操作野指针。delete空指针是安全的，delete野指针会导致程序的崩溃。

delete ptr;
ptr = nullptr;

如果析构函数被调用了多次，如果没有ptr = nullptr;，那么delete ptr;操作的就是野指针。
所以，在析构函数中，释放堆区内存后，也应该把指针指向空。
对于基类，即使不需要析构函数，也应该提供一个空虚析构函数。目的是为了让派生类有机会可以重写析构函数。
下面的代码就演示了，基类没有析构函数，派生类有析构函数的情况：

#include <iostream>using namespace std;class AA
{
public:AA() {cout << "调用了基类构造" << endl;}virtual void func() {cout << "调用了基类 func()" << endl;}// 基类缺少析构函数// virtual ~AA() {cout << "调用了基类析构！" << endl;} };class BB : public AA
{
public:BB() {cout << "调用了子类构造" << endl;}void func() {cout << "调用了子类 func()" << endl;}~BB() {cout << "调用了子类析构！" << endl;}};int main() {AA* aa_ptr = new BB; // 基类指针指向派生类对象delete aa_ptr; // 基类指针释放派生类对象return 0;
}

编译运行结果如下：

调用了基类构造
调用了子类构造

可以发现，销毁派生类对象时，没有调用析构函数，因为基类指针不能调用派生类的成员函数。若想调用派生类的构造函数，在基类中添加一个空的虚构函数即可。代码如下：

class AA
{
public:AA() {cout << "调用了基类构造" << endl;}virtual void func() {cout << "调用了基类 func()" << endl;}// virtual ~AA() {cout << "调用了基类析构！" << endl;}virtual ~AA() {} // 空的析构函数
};

编译运行的结果如下：

调用了基类构造
调用了子类构造
调用了子类析构！

纯虚构函数和抽象类

纯虚函数是一种特殊的虚函数，在某些情况下，基类中不能对虚函数给出有意义的实现，把它声明为纯虚函数。
纯虚函数只有函数名、参数和返回值类型，没有函数体，具体实现留给该派生类去做。
语法：virtual 返回值类型 函数名 (参数列表)=0;
纯虚函数在基类中为派生类保留一个函数的名字，以便派生类它进行重定义。如果在基类中没有保留函数名字，则无法支持多态性。
含有纯虚函数的类被称为抽象类，不能实例化对象，可以创建指针和引用。
派生类必须重定义抽象类中的纯虚函数，否则也属于抽象类。
比较好理解，直接看代码：

#include <iostream>using namespace std;class AA // 含有纯虚函数的类——抽象类
{
public:AA() {cout << "调用了基类构造" << endl;}virtual void func() = 0; // 纯虚函数virtual ~AA() {cout << "调用了基类析构！" << endl;}
};class BB : public AA // 派生类
{
public:BB() {cout << "调用了子类构造" << endl;}void func() {cout << "调用了子类 func()" << endl;}~BB() {cout << "调用了子类析构！" << endl;}
};int main() {BB bb; // 创建派生类对象AA* aa_ptr = &bb; // 创建抽象类指针，指向子类对象。aa_ptr->func(); // 调用子类 func()// AA& aa_ref = bb; // 创建抽象类引用，指向子类对象。// aa_ref.func(); // 调用子类 func()return 0;
}

编译运行的效果如下：

调用了基类构造
调用了子类构造
调用了子类 func()
调用了子类析构！
调用了基类析构！

基类中的纯虚析构函数也需要实现。

class AA // 抽象类
{
public:AA() {cout << "调用了基类构造" << endl;}virtual void func() = 0;virtual ~AA() = 0;
};

这段代码编译会通过，但是链接过程中会报错。原因是：当派生类对象被销毁时，会调用派生类的析构函数，接着自动调用基类的析构函数。现在基类的析构函数没有代码实现了，所以报错了。这种错误是链接阶段的，不是编译阶段的。
既然纯虚析构函数一定要有代码实现，那它还有啥意义？
有时候，想使一个类成为抽象类，但刚好又没有任何纯虚函数，怎么办？
方法很简单：在想要成为抽象类的类中声明一个纯虚析构函数。
纯虚析构函数的定义要在类的外部

class AA // 抽象类
{
public:AA() {cout << "调用了基类构造" << endl;}virtual void func() = 0;virtual ~AA() = 0; // 纯虚析构函数声明
};AA::~AA() {cout << "调用了基类析构！" << endl;}; // 纯虚析构函数定义

感谢浏览，一起学习！