析构函数只能有一个，不能带参数，析构函数不能被重载，构造函数可以被
重载，应该说有了类才能产生一个析构函数

为类开辟空间进行函数调用和函数析构：

  1. #include<iostream>
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. using namespace std;
  5. class Myclass
  6. {
  7. public:
  8.     Myclass(){cout<<"A";}
  9.     Myclass(char c){cout<<"C";}
  10.     ~Myclass(){cout<<"B";}
  11. };
  12. int main()
  13. {
  14.     Myclass my1,*p1;
  15.     p1=new Myclass[10];//作用是为p1开辟十个类大小的内存空间，需要调用十次构造函数 。 
  16.     delete []p1;//作用是析构全部对象 需要调用十次析构函数。 
  17.     return 0;
  18. }

一、析构函数的定义


析构函数为成员函数的一种，名字与类名相同，在前面加‘~’没有参数和返回值在C++中“~”是位取反运算符。
一个类最多只能有一个析构函数。析构函数不返回任何值，没有函数类型，也没有函数参数，因此它不能被重载。
构造函数可能有多个，但析构函数只能有一个，就像人来到人世间，可能出生的环境家庭不同（重载构造函数），但最终都会死亡（析构函数）。

  1. class C
  2. {
  3. public:
  4.     ~C ( ) { }
  5.     ~C (int i) { }    // error C2524: “C”: 析构函数 必须有“void”参数列表
  6.     // warning C4523: “C”: 指定了多个析构函数
  7. };

析构函数对象消亡时即自动被调用。可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等。
如果定义类时没写析构函数，则编译器生成缺省析构函数。缺省析构函数什么也不做。如果定义了析构函数，则编译器不生成缺省析构函数。
析构函数的作用并不是删除对象，而是在撤销对象占用的内存之前完成一些清理工作。
例：

  1. class A
  2. {
  3. private :
  4.     char * p;
  5. public:
  6.     A ( )
  7.     {
  8.         p = new char[10];
  9.     }
  10.     ~ A ( )
  11.     {
  12.         delete [] p;
  13.     }
  14. };

若A类没写析构函数，则在生成A对象后，new出来的内存空间未清除，可能造成内存泄露。

在创建一类的对象数组时，对于每一个数组元素，都会执行缺省的构造函数。同样，对象数组生命期结束时，对象数组的每个元素的析构函数都会被调用。

  1. #include<iostream>
  2. using namespace std;
  3. unsigned count = 0;
  4. class A
  5. {
  6. public:
  7.     A ( )
  8.     {
  9.         i = ++count;
  10.         cout << "Creating A " << i <<endl;
  11.     }
  12.     ~A ( )
  13.     {
  14.         cout << "A Destructor called " << i <<endl;
  15.     }
  16. private :
  17.     int i;
  18. };
  19. int main( )
  20. {
  21.     A ar[3];  // 对象数组
  22.     return 0;
  23. }

程序执行结果为：
Creating A 1
Creating A 2
Creating A 3
A Destructor called 3
A Destructor called 2
A Destructor called 1
类似于栈的后进先出

二、析构函数的调用


如果出现以下几种情况，程序就会执行析构函数：
（1）如果在一个函数中定义了一个对象(它是自动局部对象)，当这个函数被调用结束时，对象应该释放，在对象释放前自动执行析构函数。
（2）static局部对象在函数调用结束时对象并不释放，因此也不调用析构函数，只在main函数结束或调用exit函数结束程序时，才调用static局部对象的析构函数。
（3）如果定义了一个全局对象，则在程序的流程离开其作用域时(如main函数结束或调用exit函数) 时，调用该全局对象的析构函数。
（4）如果用new运算符动态地建立了一个对象，当用delete运算符释放该对象时，先调用该对象的析构函数。
（5）调用复制构造函数后。
例：

  1. 例4.35
  2. #include <iostream>
  3. using namespace std;
  4. class CMyclass
  5. {
  6. public:
  7.     ~CMyclass( )
  8.     {
  9.         cout << "destructor" << endl;
  10.     }
  11. };
  12. CMyclass obj;
  13. CMyclass fun(CMyclass sobj )
  14. {
  15.     return sobj;   //函数调用返回时生成临时对象返回
  16. }
  17. void main( )
  18. {
  19.     obj = fun(obj);  //函数调用的返回值（临时对象）被用过后，该临时对象析构函数被调用
  20. }

程序执行结果为：
destructor // 形参和实参结合，会调用复制构造函数，临时对象析构
destructor // return sobj函数调用返回，会调用复制构造函数，临时对象析构
destructor // obj对象析构

总之，在临时对象生成的时候会有构造函数被调用,临时对象消亡导致析构函数调用。

三、构造函数和析构函数的调用情况


构造函数用于对对象中的变量赋初值，析构函数用于释放所定义的对象的所有内存空间。构造函数和析构函数都不需要用户调用的，构造函数在定义对象时自动调用，析构函数当对象的生存期结束的时候会自动的调用。一般来说，析构函数的调用顺序与构造函数相反。但对象存储类型可以改变析构函数的调用顺序。
全局范围中定义的对象的构造函数在文件中的任何其他函数(包括main)执行之前调用(但不同文件之间全局对象构造函数的执行顺序是不确定的)。全局变量是需要在进入main()函数前即初始化的，所以在一个程序中一个全局变量的构造函数应该是第一个被调用的，比main()函数都要早。同时全局对象又必须在main()函数返回后才被销毁，当main终止或调用exit函数时调用相应的析构函数，所以它的析构函数是最后才被调用。
当程序执行到对象定义时，调用自动局部对象的构造函数。该对象的析构函数在对象离开范围时调用(即离开定义对象的块时)。自动对象的构造函数与析构函数在每次对象进人和离开范围时调用。
static局部对象的构造函数只在程序执行首次到达对象定义时调用一次，对应的析构函数在main终止或调用exit函数时调用。

  1. #include <iostream>
  2. using namespace std;
  3. class A
  4. {
  5. public:
  6.     A( int value )
  7.     {
  8.         i = value;
  9.         cout << "Object "<<i<<" constructor";
  10.     }
  11.     ~A()    // destructor
  12.     {
  13.         cout <<"Object "<<i<<" destructor"<< endl;
  14.     }
  15. private:
  16.     int i;
  17. };
  18. A first(1);  // global object全局变量
  19. void func()
  20. {
  21.     A fifth(5);
  22.     cout <<" (local automatic in create)"<< endl;
  23.     static A sixth( 6 );
  24.     cout <<" (local static in create)"<< endl;
  25.     A seventh(7);
  26.     cout <<" (local automatic in create)"<< endl;
  27. }
  28. int main()
  29. {
  30.     cout <<" (global created before main)" <<endl;
  31.     A second(2);
  32.     cout <<" (local automatic in main)"<< endl;
  33.     static A third(3);  // local object
  34.     cout <<" (local static in main)"<< endl;
  35.     func();     // call function to create objects
  36.     A fourth(4);      // local object
  37.     cout <<" (local automatic in main)"<< endl;
  38.     return 0;
  39. }

程序执行结果为：
Object 1 constructor (global creasted before main)
Object 2 constructor (local automatic in main)
Object 3 constructor (local static in main)
Object 5 constructor (local automatic in create)
Object 6 constructor (local static in create)
Object 7 constructor (local automatic in create)
Object 7 destructor
Object 5 destructor
Object 4 constructor (local automatic in main}
Object 4 destructor
Object 2 destructor
Object 6 destructor
Object 3 destructor
Object 1 destructor
上例中，main函数中声明3个对象，对象second和fourth是局部自动对象，对象third是static局部对象。这些对象的构造函数在程序执行到对象定义时调用。对象fourth和second的析构函数在到达main函数结尾时候依次调用。由于对象third是static局部对象，因此到程序结束时才退出，在程序终止时候删除所有其他对象之后和调用first的析构函数之前调用对象third的析构函数。函数func声明3个对象。对象fifth和seventh是局部自动对象，对象sixth是static局部对象。对象seventh和fifth的析构函数在到func结束时候依次调用。由于对象sixth是static局部对象，因此到程序结束时才退出。sixth的析构函数在程序终止时删除所有其他对象之后和调用third和first的析构函数之前调用。

若函数参数是类类型，调用函数时要调用复制构造函数，用实际参数初始化形式参数。当函数返回类类型时，也要通过复制构造函数建立临时对象。
例：

  1. #include <iostream>
  2. using namespace std;
  3. class A
  4. {
  5. public:
  6.     A()
  7.     {
  8.         cout<<"A constructor"<<endl;
  9.     }
  10.     ~A()
  11.     {
  12.         cout<<"A destructor"<<endl;
  13.     }
  14.     A(A &)
  15.     {
  16.         cout <<"A copy constructor"<<endl;
  17.     }
  18. };
  19. class B
  20. {
  21. public:
  22.     B()
  23.     {
  24.         cout<<"B constructor"<<endl;
  25.     }
  26.     ~B()
  27.     {
  28.         cout<<"B destructor"<<endl;
  29.     }
  30.     B(B &)
  31.     {
  32.         cout<<"B copy constructor"<<endl;
  33.     }
  34. };
  35. A a;
  36. B b;
  37. void func1(A obj) {}
  38. void func2(B &obj) {}
  39. int main()
  40. {
  41.     func1(a);
  42.     func2(b);
  43.     return 0;
  44. }

程序执行结果为：
A constructor // a构造
B constructor // b构造
A copy constructor // func1函数参数调用A的复制构造函数
A destructor // func1函数参数析构
B destructor // b析构
A destructor // a析构
上例中函数func1的参数是A的值传递方式，实参初始化形参时需要调用复制构造函数，函数调用结束后，栈上的形参消亡时要调用A的析构函数。函数func2的参数是B的引用传递方式，形参只是实参的一个别名，并没有创建新的对象，因此不会调用复制构造函数和析构函数。

这里再附上一道面试题：

  1. #include <iostream>
  2. using namespace std;
  3. void hello( )
  4. {
  5.     cout << "  Hello, world!\n";
  6. }
  7. int main( )
  8. {
  9.     hello( );
  10.     return 0;
  11. }

试修改上面的程序，使其输出变成：
Begin
Hello, world!
End
限制：(1)不能对main()进行任何修改；(2)不能修改hello()函数。
这里用到了构造函数和析构函数的调用了。

  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. public:
  5.   A ( ) { cout << "Begin\n"; }
  6.   ~A ( ) { cout << "End\n"; }
  7. };
  9. void hello( ) {cout << "  Hello, world!\n"; }
  11. A a;      // a是一个全局对象
  12. int main( ) {
  13.   hello( ); 
  14.   return 0;
  15. }

下面总结下不同存储类型构造函数和析构函数的调用。

构造函数的调用：
（1）全局变量：程序运行前；
（2）函数中静态变量：函数开始前；
（3）函数参数：函数开始前；
（4）函数返回值：函数返回前；
析构函数的调用：
（1）全局变量：程序结束前;
（2）main中变量：main结束前；
（3）函数中静态变量：程序结束前；
（4）函数参数：函数结束前；
（5）函数中变量：函数结束前；
（6）函数返回值：函数返回值被使用后；
对于相同作用域和存储类别的对象，调用析构函数的次序正好与调用构造函数的次序相反

四、私有析构函数


有时你想这样管理某些对象，要让某种类型的对象能够自我销毁，也就是能够“delete this”。很明显这种管理方式需要此类型对象被分配在堆中。若我们必须在堆中创建对象，为了执行这种限制，你必须找到一种方法禁止以调用“new”以外的其它手段建立对象。这很容易做到，非堆对象(non-heap object)，即栈对象在定义它的地方被自动构造，在生存时间结束时自动被释放，所以只要禁止使用隐式的析构函数，就可以实现这种限制。
把这些调用变得不合法的一种最直接的方法是把析构函数声明为private，把构造函数声明为public。你可以增加一个专用的伪析构函数，用来访问真正的析构函数，客户端调用伪析构函数释放他们建立的对象。

  1. #include <iostream>
  2. using namespace std;
  3. class A
  4. {
  5. public:
  6.     A()
  7.     {
  8.         cout<<"A"<<endl;
  9.     }
  10.     void destroy() const
  11.     {
  12.         cout<<"delete A"<<endl;
  13.         delete this;
  14.     }
  15. private:
  16.     ~A() {}
  17. };
  18. int main( )
  19. {
  20.     A *pa = new A;
  21.     pa->destroy();
  22.     return 0;
  23. }

程序执行结果为：
A
delete A
若A类对象是在栈上创建：
A a; // error C2248: “A::~A”: 无法访问 private 成员(在“A”类中声明)
编译时会提示不能访问私有成员。因为在栈上生成对象时，类对象在离开作用域时会调用析构函数释放空间，此时无法调用私有的析构函数。C++在编译过程中，所有的非虚函数调用都必须分析完成。即使是虚函数，也需检查可访问性。因此，当在栈上生成对象时，对象会自动析构，也就说析构函数必须可以访问。而堆上生成对象，由于析构时机由程序员控制，所以不一定需要析构函数。

被声明为私有析构函数的类对象只能在堆上创建，并且该类不能被继承。

  1. class A
  2. {
  3. private:
  4.     ~A() {}
  5. };
  6. class B : public A
  7. {
  8.     // error C2248: “A::~A”: 无法访问 private 成员(在“A”类中声明)
  9. }  // warning C4624: “B”: 未能生成析构函数，因为基类析构函数不可访问

网址 ：超牛逼的 一位大佬