概念

前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的?

与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

特性

:
析构函数是特殊的成员函数。

其特征如下:

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。（析构函数不能重载）
3. 一个类有且只有一个析构函数。（若未显式定义，系统会自动生成默认的析构函数）
4. 对象生命周期结束时，C++编译系统系统（编译器）自动调用析构函数，完成对象中资源的清理。

typedef int DataType;

class SeqList
{
public :
    SeqList (int capacity = 10)
    {
        _pData = (DataType*)malloc(capacity * sizeof(DataType));
        assert(_pData);
        _size = 0;
        _capacity = capacity;
    }
    ~SeqList() {
    if (_pData) {
		free(_pData );    // 释放堆上的空间
        _pData = NULL;    // 将指针置为空
        _capacity = 0;
        _size = 0;
    } 
}
private :
    int* _pData ;
    size_t _size;
    size_t _capacity;
};

5. 通过下面的程序我们会看到，编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。

class String
{
public:
    String(const char* str = "jack")
    {
        _str = (char*)malloc(strlen(str) + 1);
        strcpy(_str, str);
    }
    ~String() 
    {
        cout << "~String()" << endl;
        free(_str);
    }
private:
    char* _str;
};

class Person
{
private:
    String _name;
    int _age; 
};

int main() 
{
    Person p;
    return 0; 
}

注意：

类中如果没有涉及到资源管理时，析构函数是否给出无所谓；但是如果涉及到资源管理，用户必须要显式给出析构函数，在析构函数中清理对象的资源。

知识点习题

1. 有如下程序，执行后输出的结果是( )

#include <iostream.h>
class cla{
    static int n;
    public:
     cla(){n++;}
    ~cla(){n--;}
    static int get_n(){return n;}
};
int cla::n= 0;
int main()
{
   cla *p =new cla;
   delete p;
   cout<<"n="<<cla::get_n()<<endl;
   return 0;
}

A. n=3
B. n=4
C. n=1
D. n=0

正确答案:

D

答案解析：

类的实例化：cla *p = new cla，p分配在栈上，p指向的对象分配在堆上。
n为静态成员变量，没有this指针，属于类域，所有对象共享。
实例化——调用构造函数，所以n++；
delete——调用析构函数，所以n–。
最后输仍旧为0。

2. 如果有一个类是 myClass , 关于下面代码正确描述的是:

myClass::~myClass(){ 
	delete this;
	this = NULL;
}

A. 正确，我们避免了内存泄漏
B. 它会导致栈溢出
C. 无法编译通过
D. 这是不正确的，它没有释放任何成员变量。

正确答案

C

答案解析

1.在类A的析构函数中，delete一个非A类对象通常是没有问题的；
在类A的析构函数中，delete一个类A的对象，就会造成死循环，堆栈溢出；
在析构函数外使用 delete后，应该立即给指针赋值 NULL防止野指针。

2.因为this是Myclass * const this指针，也就是说this指针指向的对象(不是指向的对象的值)不可以改变，所以给this赋值在编译期间就不会通过，如果没有this = NULL这语句的话是栈溢出，因为会不停的调用析构函数。

3.this被const修饰不能修改。 删掉this＝null后，在类的析构函数中调用delete this,delete this会去调用本对象的析构函数，而析构函数中又调用delete this，形成无限递归，造成堆栈溢出，系统崩溃。

3. 分析一下这段程序的输出

#include<iostream>
 using namespace std;
 class B
 {
 public:
     B()
     {
         cout << "default constructor" << " ";
     }
     ~B()
     {
         cout << "destructed" << " ";
     }
     B(int i): data(i)
     {
         cout << "constructed by parameter" << data << " ";
     } 
     private: int data;
 }; 
 B Play( B b)
 {
     return b;
 } 
 int main(int argc, char *argv[])
 {
     B temp = Play(5);
     return 0;
 }

A. constructed by parameter5 destructed destructed
B. constructed by parameter5 destructed
C. default constructor" constructed by parameter5 destructed
D. default constructor" constructed by parameter5 destructed destructed

正确答案

A

答案解析

从赋值右边开始执行

调用Play函数需要将5隐式类型转换为Play函数中的形参b，会调用B的B(int i): data(i)，打印“constructed by parameter5”。
Play函数返回时需要调用B的拷贝构造函数给对象temp初始化。
Play函数返回后需要调用b的析构函数，将Play函数的形参释放，打印“destructed”。
main函数返回后需要释放temp，打印“destructed”。

4. 关于以下代码，哪个说法是正确的？

myClass::foo(){
    delete this;
}
..
void func(){
    myClass *a = new myClass();
    a->foo();
}

A. 它会引起栈溢出
B. 都不正确
C. 它不能编译
D. 它会引起段错误

正确答案：

B

答案解析：

delete this（对象请求自杀）是允许的，但是必须保证:

• 1: 该this对象是100%new出来的，并且是最普通的new出来的，不能是new[]，定位new等等
• 2: 该成员函数是this对象最后调用的成员函数（因为成员函数第一个参数是隐藏的this指针）
• 3: delete this之后必须保证不能访问到成员变量和虚函数（调用完delete this 之后，对象的内存空间被释放了，导致不能再访问数据成员和虚函数）
• 4: delete this不能放在析构函数中，否则递归 （导致堆栈溢出）

题目中this对象是通过最普通的new产生的，并且之调用了foo成员函数，即保证了foo是最后一个this调用的成员函数，且之后没有访问成员函数和虚函数的操作，因此没有问题。

5. 设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？

C c;
void main()
{
    A*pa=new A();
    B b;
    static D d;
    delete pa;
}

A. A B C D
B. A B D C
C. A C D B
D. A C B D

正确答案: B

答案解析

这道题主要考察的知识点是 ：全局变量，静态局部变量，局部变量空间的堆分配和栈分配

其中全局变量和静态局部变量时从 静态存储区中划分的空间，
二者的区别在于作用域的不同，全局变量作用域大于静态局部变量（只用于声明它的函数中），
而之所以是先释放 D 在释放 C的原因是， 程序中首先调用的是 C的构造函数，然后调用的是 D 的构造函数，析构函数的调用与构造函数的调用顺序刚好相反。

局部变量A 是通过 new 从系统的堆空间中分配的，程序运行结束之后，系统是不会自动回收分配给它的空间的，需要程序员手动调用 delete 来释放。

局部变量 B 对象的空间来自于系统的栈空间，在该方法执行结束就会由系统自动通过调用析构方法将其空间释放。

之所以是 先 A 后 B 是因为，B 是在函数执行到 结尾 “}” 的时候才调用析构函数， 而语句 delete a ; 位于函数结尾 “}” 之前。

如果有不同见解，欢迎留言讨论

c++析构函数
首先我们来看一下有关析构函数的文字描述
1、定义
析构函数(destructor) 与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）。
2、 作用：对象消亡时，自动被调用，用来释放对象占用的空间
3、特点:
(1) 名字与类名相同
(2) 在前面需要加上"~"
(3) 无参数，无返回值
(4) 一个类最多只有一个析构函数
(5) 不显示定义析构函数会调用缺省析构函数

#include<iostream>
using namespace std;
class Test
{
    int id;
public:
	Test()
	{
	}
    Test(int i)
    {
        id = i;
    }
    ~Test()
    {
        cout<<"ID: "<<id<<" destruction function is invoked!"<<endl;
    };
};

int main()
{
    Test t0(0);                   //栈中分配   
	Test t1[3]={1,1,1};           //栈中分配 

    Test *t2 = new Test(2);       //堆中分配
    delete t2;

	Test *t3 = new Test[3]{3,3,3}; //堆中分配
    delete []t3;
    
    cout<<"------End of Main-------"<<endl;
    return 0;
}

在给出运行结果以前有必要说一下，我在vs2012的编译器里也运行了这段代码。但是其中Test *t3 = new Test[3]{3,3,3};这行代码是有错误的，我去查阅了相关的博客资料发现，在C++11中引进了这一新功能，即用new申请动态数组时可以直接初始化，形式如下：

int* p = new int[cnt]（）;  //其中cnt长度和int类型都可以自己定义。
int* p = new int[cnt]{ };

而且可以用这个方式给每个成员赋值。

int* a = new int[10] { 1,2,3,4,5,6,7,8,9,10 }; 

所以说上面的Test *t3 = new Test[3]{3,3,3};语句就应该是没问题的，下面给出运行结果。

解释：
在main函数中创建了t0,t1,t2,t3几个对象，这里先说一下C++创建对象的三种不同方式：

1、Test t0(0）;                                    //栈中分配内存

2、Test t1[3]={1,1,1};    　　　　　 //栈中分配内存

3、Test *t2 = new Test(2);   　 //堆中分配内存

4、Test *t3 = new Test[3]{3,3,3};　　　 //堆中分配内存

方法1、2中都是在栈中分配内存，在栈中内存由系统自动的去分配和释放，而使用new创建的指针对象是在堆中分配内存，当不需要该对象时，需要我们手动的去释放(delete)，否则会造成内存泄漏。

在上述程序中，t0和t1都是栈中的对象，在程序结束时由系统来释放，因此出现在-----End of Main----之后。t2，t3是new出来的堆中对象，所以需要手动的delete释放，因此出现在最前面。另外有一点发现，就是栈中对象的释放顺序，是后定义的先释放，经过几次验证也如此，我想这恰好应征了栈的后进先出的特征。(先释放1，后释放0)

class Test
{
    int id;
public:
    Test(int i)
    {
        id = i;
    }
    ~Test()
    {
        cout<<"ID: "<<id<<" destruction function is invoked!"<<endl;
    };
};

Test t0(0);　　                      //最先创建的对象，最后释放

void Func()
{
    static Test t1(1);               
    //创建静态对象，会在整个程序结束时自动释放
    Test t2(2);　　　　　　　　　　　　 //在Func结束时自动释放
    cout<<"-----Func-----"<<endl;
}

int main()
{
    Test t3(3);
    t3 = 10;                         
    //类型转换构造函数，这里会创建临时对象，将int型转成Test类型对象，
    //在赋值结束后，临时变量销毁
    cout<<"------Begin of Main-------"<<endl;
    {
        Test t4(4);                 
         //花括号代表作用域，不需要等到main方法结束就释放了
    }
    Func();                          //进入Func函数
    cout<<"------End of Main-------"<<endl;
    return 0;
}

那让我们先分析一波 先是t3，t3创建完成以后想要把10赋值过来，但是一个是int类型，一个是Test，这里就会创建临时对象，将int型转成Test类型对象，在赋值结束后，临时变量销毁（把临时创建的对象得10赋值给了t3），销毁临时对象，调用一次析构函数，然后是------Begin of Main-------，到了t4，因为是在花括号里，直接调用了一次析构函数，不需要等到main方法结束，（此处如果没有花括号那么它应该在哪里呢，答案当然是在t3前面 也就是------End of Main-------之后的10前面），到了Func(); 里面的t1和t2，t1静态对象，会在整个程序结束时自动释放，t2在Func()结束时释放，所以先------Func------在调用析构函数，然后------End of Main-------，接着是释放t3，静态t1，最前面最先定义的t0;

析构函数

2.1 析构函数定义和使用

       析构函数（destructor）是一个特殊的成员函数，它的作用与构造函数相反，它的名字是类名的前面加一个“～”符号。在C++中“～”是位“取反”运算符，从这一点可以想到：析构函数是与构造函数作用相反的函数。例如：

class student{

public:

    student()//构造函数

    {

    }

    ~student() //析构函数

    {   }

    void print(){}

};

       可以看到，定义了一个student类。然后，定义student类的构造函数和析构函数。其中，析构函数的定义如下：

~student(){ }

       那么，函数名是类名前面添加取反符号“~”，而且，函数没有参数。

       当对象的生命周期结束的时候，就会自动执行析构函数。如果出现以下几种情况，程序就会执行析构函数：

(1) 如果在一个函数中定义了一个对象，那么，该对象就是局部对象，当这个函数被调用结束时，对象的生命周期结束。此时，对象应该释放（销毁），在对象释放（销毁）前自动执行析构函数。

(2) static 局部对象在函数调用结束时对象并不释放（销毁），因此，不调用析构函数，只在main() 函数结束或调用exit()函数结束程序的时候，才调用static局部对象的析构函数。

因为static局部对象的生命周期是整个程序运行过程，所以，只有程序结束运行的时候，static局部对象的生命周期才结束，才执行类的析构函数。

(3) 如果定义了一个全局对象，全局对象的生命周期是整个程序运行过程，所以，当程序结束运行的时候，全局对象才销毁，此时，调用该全局对象的析构函数。

(4) 如果用new运算符动态地建立了一个对象，当用delete运算符释放该对象时，先调用该对象的析构函数。

       析构函数的作用并不是删除对象，而是在撤销对象占用的内存之前，完成一些清理工作。使这部分内存可以被程序分配给新对象使用。程序设计者要设计好析构函数，以完成所需的功能，只要对象的生命周期结束，程序就会自动执行析构函数来完成这些工作。

       析构函数不返回任何数值，也没有函数类型 和 函数参数。由于没有函数参数，因此，它不能被重载。一个类可以有多个构造函数，但是，只能有一个析构函数。

       一般情况下，类的设计者应当在声明类的同时定义析构函数，以指定如何完成“清理”的工作。如果用户没有定义析构函数，C++编译系统会自动生成一个 默认析构函数，但是，它只是有析构函数的名称和形式，实际上什么操作都不进行。想让析构函数完成任何工作，都必须在定义的析构函数中执行。

       如下是一个程序测试例子，讲解构造函数和析构函数的使用。

       程序运行结果如下：

       在main()函数中，定义一个if(1){}代码块，在代码块中定义stud局部变量。当退出代

码块的时候，销毁stud局部变量，看到析构函数的调用。

       所以，我们看到对象销毁的时候，自动调用析构函数。析构函数是不可以手动调用的。是对象销毁的时候，由系统自动调用。

       所以，对象销毁的时候，我们想释放一些资源，就可以放在析构函数中操作。例如，student类中的name, addr是动态申请的内存。那么，在析构函数中就释放这些内存。

韦凯峰 Linux C/C++ 程序设计教程，Linux 系统编程，Openwrt 系统开发，微信:13926572996,QQ:1523520001,博客:www.mylinux.vip