C/C++编程：析构函数

川长思鸟来 2022-11-15 11:14 240阅读 0赞

>  *  构造函数初始化对象。换句话说，它创建供成员函数进行操作的环境。创建环境有时需要获取资源，比如文件、锁、内存，这些函数必须在使用后释放。从而引入了一个析构函数，在对象销毁时就一定会自动调用析构函数，就像对象创建时一定会调用构造函数一样

# 声明析构函数 #

*  析构函数是一个成员函数，该函数**在对象(自动变量)超出范围时自动调用，或者通过delete显式调用**，每个类只能有一个析构函数。
 *  析构函数具有与类相同的名称，前面有一个波形符 (~) 。 例如，声明 String 类的析构函数：`~String()。`
 *  如果未定义析构函数，则编译器将提供一个默认析构函数。对于许多类，这就足够了。仅当类将句柄存储到需要释放的系统资源或拥有它们指向的内存的指针时，才需要定义自定义析构函数。

多个规则管理析构函数的声明。 析构函数：

*  不接受任何参数
 *  不要将值返回 (或 void) 。
 *  不能声明为 const 、 volatile 或 static 。 但是，可以调用它们来销毁作为、或声明的对象`const volatile static` 。
 *  可以声明为`virtual`。通过使用虚拟析构函数，无需知道对象的类型即可销毁对象：使用虚函数机制调用该对象的正确析构函数。请注意，析构函数也可以声明为抽象类的纯虚函数。

#include <stdlib.h>
    #include <string.h> 
    
    using namespace std;
    
    class String {
        
    public:
       String( char *ch );  //声明构造函数
       ~String();           //声明析构函数
    private:
       char    *_text;
       size_t  sizeOfText;
    };
    
    //定义构造函数。
    String::String( char *ch ) {
        
       sizeOfText = strlen( ch ) + 1;
    
       //动态分配正确数量的内存。
       _text = new char[ sizeOfText ];
    
       //如果分配成功，复制初始化字符串。
       if( _text )
          strcpy_s( _text, sizeOfText, ch );
    }
    
    // 定义析构函数。
    String::~String() {
        
       // 释放以前为此字符串保留的内存。
       delete[] _text;
    }
    
    int main() {
        
       String str("The piper in the glen...");
    
    	String p= new String('a');
    	delete p;
    }

# 调用构造函数 #

当下列事件之一发生时，将调用析构函数：

*  具有块范围的本地（自动）对象超出范围。
 *  使用运算符分配的对象`new`使用进行了显式释放`delete`。
 *  临时对象的生存期结束
 *  程序结束，并且存在全局或者静态对象
 *  使用析构函数的完全限定名显式调用了析构函数

析构函数可以随意调用类成员函数和访问类数据

对析构函数的使用有两个限制：

*  不能采用其地址
 *  **派生类不继承其基类的析构函数**

> 应用：对象必须显式销毁，不能隐式销毁；对象必须通过new来创建

如果为类X声明了一个析构函数，那么每当一个X离开作用域或者被delete释放时，析构函数就会被隐式调用。这意味着我们通过声明X的析构函数为=delete或者private，就可以阻止其析构。

在两种方法中，使用private更为灵活：

class NonLocal{
        
    public:
    	...
    	void destroy() {
        this->~Nonlocal();};
    private:
    	~NonLocal();
    };
    
    void user(){
        
    	NonLocal xl;          // error, 不能析构一个NonLocal 
    	X *p = new NonLocal ; //ok
    	delete p;             // error, 不能析构一个NonLocal 
    	p.destory();          //ok
    }

# 析构的顺序 #

构造函数与析构函数可以很好的与类层次配合。构造函数会“自上而下”的创建一个类对象

*  首先，构造函数调用其基类的构造函数
 *  然后，调用成员函数的构造函数
 *  最好，执行自身的构造函数

析构函数以相反顺序“拆除”一个对象：

*  将调用自身的析构函数
 *  按照**非静态成员对象的析构函数**在类声明中的显式顺序的相反顺序调用这些函数。构造这些成员时使用可选成员初始化列表不会影响构造或者析构的顺序
 *  **非虚拟基类的析构函数**以相反顺序调用
 *  **虚拟基类的析构函数**以声明的相反顺序被调用

特别的，一个虚基类必须在任何可能使用它的基类之前**构造**，并在它们之后销毁。这种顺序保证了一个基类或者一个成员不会在它初始化完成之前或者已经被销毁之后使用。（虽然可以故意规避但请不要这样，否则将造成灾难性后果）

构造函数按照声明顺序(而非初始化顺序)执行成员和基类的构造函数：如果两个构造函数使用了不同的顺序，析构函数不能保证(即使能保证也会有严重的开销)按照构造相反顺序进行销毁。

#include <cstdio>
    
    struct A1      {
         virtual ~A1() {
         printf("A1 dtor\n"); } };
    struct A2 : A1 {
         virtual ~A2() {
         printf("A2 dtor\n"); } };
    struct A3 : A2 {
         virtual ~A3() {
         printf("A3 dtor\n"); } };
    
    struct B1      {
         ~B1() {
         printf("B1 dtor\n"); } };
    struct B2 : B1 {
         ~B2() {
         printf("B2 dtor\n"); } };
    struct B3 : B2 {
         ~B3() {
         printf("B3 dtor\n"); } };
    
    int main() {
        
       A1 * a = new A3;
       delete a;
       printf("\n");
    
       B1 * b = new B3;
       delete b;
       printf("\n");
    
       B3 * b2 = new B3;
       delete b2;
    }

![在这里插入图片描述][2021040109172026.png]

## 非虚拟基类 ##

非虚拟基类的析构函数以声明基类名称的反向顺序调用。 考虑下列类声明：

class MultInherit : public Base1, public Base2
    ...

在前面的示例中，先于 Base2 , 再调用 Base1 的析构函数。

# 显式析构函数调用 #

*  很少需要显式调用析构函数，可能会导致严重的错误
 *  **显式调用析构函数**对置于绝对地址的对象进行清理会很有用。这些对象通常采用`布置new`运算符进行分配。`delete`无法释放此内存，因为它不是从免费存储分配。但是，对析构函数的调用可以执行相应的清理。如果要显式调用`s`类的对象`string`的析构函数，请使用下列语句之一：

s.String::~String();     // non-virtual call
    ps->String::~String();   // non-virtual call
    
    s.~String();       // Virtual call
    ps->~String();     // Virtual call

# 虚析构函数 #

析构函数可以声明为virtual，而且对于含有虚函数的类通常就应该这么做。比如：

class Shape{
        
    public:
    	// ...
    	virtual void draw() = 0;
    	virtual ~Shape();
    };
    
    class Circle{
        
    public:
    	void draw();
    	~Circle();  //覆盖了~Shape()
    };

我们需要一个虚析构函数的原因是：如果通常是通过基类提供的接口来操作一个对象，那么通常也应该通过此接口来delete它：

void user(Shape *p){
        
    	p->draw();  // 调用恰当的draw();
    	//...
    	delete p;
    }

假如Shape的析构函数不是virtual，则delete在尝试调用恰当的派生类的析构函数(~Circle())时就会失败。这种失败会导致被释放对象资源(如果有的话)泄漏

# 纯虚析构函数 #

纯虚析构函数和普通纯虚函数的区别在于，纯虚析构函数需要提供函数的实现，而一般纯虚函数不能有实现，这样的原因在于，纯虚析构函数最终需要被调用，以析构基类对象，虽然是抽象类没有实体。而如果不提供该析构函数的实现，将使得在析构过程中，析构无法完成而导致析构异常的问题.

#include <iostream>
    using namespace std;
     
    class Base
    {
        
    public:
    	virtual void print() =0;
     
    	virtual void print1() = 0
    	{
        
    		cout<< "Base print1" <<endl;
    	}
    	virtual ~Base() = 0
    	{
        
    		cout<< "~Base" <<endl;
    	}
    };
    class Deriver:public Base
    {
        
    public:
    	void print()
    	{
        
    		cout<< "Deriver print" <<endl;
    	}
    	void print1()
    	{
        
    		cout<< "Deriver print1" <<endl;
    	}
    	~Deriver()
    	{
        
    		cout<< "~Deriver" <<endl;
    	}
    };
    void main()
    {
        
    	Deriver d;
    	
    	d.print();
    	//d.Base::print();//error
    	d.print1();
    	d.Base::print1();
    }

也就是说： **纯虚函数可以有函数体（可以有但最好不要加）。当基类析构函数为纯虚函数时，必须显示加上函数体。**

namespace oceanstar{
        
        class  stream {
        
        public:
            stream();
            virtual ~stream() = 0;  //这是一个纯虚函数，所以stream不能生成实例
        };
    }
    
    namespace oceanstar{
        
        stream::stream(){
        
    
        }
        stream::~stream(){
         
          // 纯虚析构函数和普通纯虚函数的区别在于，纯虚析构函数需要提供函数的实现，而一般纯虚函数不能有实现，这样的原因在于，纯虚析构函数最终需要被调用，以析构基类对象，虽然是抽象类没有实体。而如果不提供该析构函数的实现，将使得在析构过程中，析构无法完成而导致析构异常的问题.
        }
    }

[2021040109172026.png]: /images/20221022/5e3fb51570fb49458d7f66d82afa572c.png