• C++构造函数与析构函数

    几乎所有的面向对象的编程语言都保护构造函数与析构函数，好学者就要举手了，啥情况啊，Java里面不就没有析构函数嘛。好吧，你问倒我了，不过可以认为Java的垃圾自动回收机制实现了对象析构的功能。管他呢，还是看C++的构造函数和析构函数吧。

    构造函数

        对于C++的构造函数，暂且将其分为以下几类：

    1. 默认构造函数

    2. 隐士转换构造函数

    3. 拷贝构造函数

    4. 其它构造函数

        1. 默认构造函数表示没有任何参数的构造函数，当自定义任何构造函数以后，将不再自动创建默认构造函数，当然，默认构造函数啥也不干，程序员关心系数顿时大跌。关于默认构造函数还需要关心的一个问题是，当本类继承于另一个类(即父类)，父类没有默认构造函数时，本类将自动没有构造函数，并且还必须定义至少能够支持父类初始化的构造函数。

        2. 隐士转换构造函数时什么呢？它是这样一类构造函数，这类构造函数仅含有一个参数。由于C++规定，为只含有一个参数的构造函数自动定义一种隐士转换，将构造函数的参数对应数据类型的对象转换为类对象。如下面例子所示： 

    [cpp] view plaincopyprint?
     
    1. class String {  
    2.      String(const char *s);  
    3. };  
    4.   
    5. String s = "hello friends";  

        其中字符串“hello friends”通过隐士转换构造函数转换为了String类对象s。这里不得不提一个关键字explicit，比较悲剧的是学了好几年C++后才知道这么一个关键字，这也充分体现了一本好书的重要性。下面来看看explicit的用法，再解释。

    [cpp] view plaincopyprint?
     
    1. class String {  
    2.     explicit String(const char *s);  
    3. };  
    4.   
    5. String s = "hello friends"; //编译不通过  
    6.   
    7. String s("hello friends");  //编译通过  

        explicit仅用于构造函数，且仅用于隐士转换构造函数，其目的是禁止隐士构造函数功能。如上代码所示，当为构造函数添加explicit关键字后，String s = "hello friends"; 编译不通过。当然，此时构造函数本身还是能够正常工作的。

        3. 拷贝构造函数,就是用来复制对象的一种特殊的构造函数。通过它，可以使用一个已经创建好的对象（由拷贝构造函数的参数指定）去初始化一个正准备创建的同类对象。

    [cpp] view plaincopyprint?
     
    1. class 类名  
    2. {  
    3. public:  
    4.     类名(类名 &对象名);  
    5. };  

        如上述代码所述，拷贝构造函数只能有一个参数，并且必须是同类对象的引用。每个类都应该有一个拷贝构造函数，如果用户没有指定，将使用默认的拷贝构造函数。默认拷贝构造函数执行对象的全部内容复制,但有时需要有选择、有变化地复制。这种情况就需要显示定义拷贝构造函数，并实现为感兴趣部分的复制或者为新对象添加某些属性值。

        拷贝构造函数最常见的使用方式是在类中含有指针类型属性时，因为默认的拷贝函数是按指拷贝的，即所谓的浅拷贝。这时需要显示定义拷贝构造函数，并显示地将指针从新分配内存并copy以前指向的值到新分配的内存中。

        4. 其它构造函数，没什么特别的，就是前面1,2,3未包含的构造函数均属于该类。  

     构造函数初始化参数列表

        以下情况下需要使用初始化成员列表：（待补充）

    一、需要初始化的数据成员是对象的情况；

    二、需要初始化const修饰的类成员；

        第一种情况，如果类A中属性存在一个类B，且类B没有不带参数的构造函数，此时初始化A时也需要初始化B，所以需要初始化参数列表。当然，此种情况一般成员属性也可以通过此种方式初始化。

        第二种情况，const成员属性不能复制，一旦初始化后就不能改变。

        下面的例子说明构造函数初始化参数列表的使用：

    [cpp] view plaincopyprint?
     
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class B  
    5. {  
    6. public:  
    7.     B(int b) {  
    8.         cout<<b<<endl;  
    9.     }  
    10. };  
    11.   
    12. class A  
    13. {  
    14. public:  
    15.     B b;  
    16.     A(int a, int ci);  
    17. private:  
    18.     const int ci;  
    19.     //const int ci = 10;    //编译错误，不能初始化    
    20.     static const int cv = 10; //添加static关键字后能够编译通过  
    21.     int c;  
    22. };  
    23.   
    24. A::A(int a, int ci):b(a),ci(ci),c(4) {  
    25.     cout << ci << "--" << c << endl;  
    26. }  
    27.   
    28. int main()  
    29. {  
    30.     A a(5, 10);  
    31.     return 0;  
    32. }  


    析构函数

       析构函数就与构造函数对应，在对象消亡时做一些善后处理。看下面的例子：

    [cpp] view plaincopyprint?
     
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A  
    5. {  
    6. public:  
    7.     A() {  
    8.         cout << "A..." << endl;  
    9.     }  
    10.     ~A() {  
    11.         cout << "~A" <<endl;  
    12.     }  
    13. };  
    14.   
    15. class B : public A  
    16. {  
    17. public:  
    18.     B() {  
    19.         cout<<"B..."<<endl;  
    20.     }  
    21.     ~B() {  
    22.         cout<<"~B"<<endl;  
    23.     }  
    24. };  
    25.   
    26. int main() {  
    27.     A *a = new B();  
    28.     delete a;  
    29.   
    30.     return 0;  
    31. }<span style="font-family: Arial, Verdana, sans-serif; white-space: normal; background-color: rgb(255, 255, 255); "> </span>  

        编译输出：

    [cpp] view plaincopyprint?
     
    1. # ./a.out   
    2. A...  
    3. B...  
    4. ~A  

        由此可见，在对象a消亡时，会自动调用对象A的析构函数。但是C++也太傻了吧，明明我实例化的B对象，可为啥析构时是调用A对象的析构函数呢？看delete a，由此可估计delete关键字只认a的对象，而不会变通。怎么能够这样...

    virtual关键字

         上面的例子显示，构造了对象B，却没有析构，这会造成啥问题呢？反正我是不清楚了。于是C++提供的virtual关键字可以解决这个问题，看下面的代码：

    [cpp] view plaincopyprint?
     
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A  
    5. {  
    6. public:  
    7.     A() {  
    8.         cout << "A..." << endl;  
    9.     }  
    10.     virtual ~A() {            //唯一区别：添加了关键字virtual  
    11.         cout << "~A" <<endl;  
    12.     }  
    13. };  
    14.   
    15. class B : public A  
    16. {  
    17. public:  
    18.     B() {  
    19.         cout<<"B..."<<endl;  
    20.     }  
    21.     ~B() {  
    22.         cout<<"~B"<<endl;  
    23.     }  
    24. };  
    25.   
    26. int main() {  
    27.     A *a = new B();  
    28.     delete a;  
    29.   
    30.     return 0;  
    31. }  

         输出：

    [cpp] view plaincopyprint?
     
    1. # ./a.out   
    2. A...  
    3. B...  
    4. ~B  
    5. ~A  

        可见，添加virtual关键字后，确实能够解决该问题，B对象也调用了析构函数。可是这是为什么呢？

        下面开始yy了，也许delete并不是那么傻，她会去虚函数表里面查看当前析构函数是否被定义为虚函数，如果是虚函数，它就会想了，那对象会不会实例化的是子类的对象呢，于是再判断是否实例化为子类对象，如果是就先调用子类的析构函数。

    1.参考文献

    参考1： C++继承中构造函数、析构函数调用顺序及虚函数的动态绑定

    参考2： 构造函数、拷贝构造函数和析构函数的的调用时刻及调用顺序

    参考3： C++构造函数与析构函数的调用顺序

    2.构造函数、析构函数与拷贝构造函数介绍

    2.1构造函数

    • 构造函数不能有返回值
    • 缺省构造函数时，系统将自动调用该缺省构造函数初始化对象，缺省构造函数会将所有数据成员都初始化为零或空 
    • 创建一个对象时，系统自动调用构造函数

    2.2析构函数

    • 析构函数没有参数，也没有返回值。不能重载，也就是说，一个类中只可能定义一个析构函数
    • 如果一个类中没有定义析构函数，系统也会自动生成一个默认的析构函数，为空函数，什么都不做
    • 调用条件：1.在函数体内定义的对象，当函数执行结束时，该对象所在类的析构函数会被自动调用；2.用new运算符动态构建的对象，在使用delete运算符释放它时。

    2.3拷贝构造函数

    拷贝构造函数实际上也是构造函数，具有一般构造函数的所有特性，其名字也与所属类名相同。拷贝构造函数中只有一个参数，这个参数是对某个同类对象的引用。它在三种情况下被调用：

    • 用类的一个已知的对象去初始化该类的另一个对象时；
    • 函数的形参是类的对象，调用函数进行形参和实参的结合时；
    • 函数的返回值是类的对象，函数执行完返回调用者。

    3.构造函数与析构函数的调用顺序

    对象是由“底层向上”开始构造的，当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的构造函数，依次类推，直至到达派生类次数最多的派生次数最多的类的构造函数为止。因为，构造函数一开始构造时，总是要调用它的基类的构造函数，然后才开始执行其构造函数体，调用直接基类构造函数时，如果无专门说明，就调用直接基类的默认构造函数。在对象析构时，其顺序正好相反。

    4.实例1

    4.1代码

    [cpp] view plaincopy
     
    1. #include<iostream>  
    2. using namespace std;  
    3. class point  
    4. {  
    5. private:  
    6.     int x,y;//数据成员  
    7. public:  
    8.     point(int xx=0,int yy=0)//构造函数  
    9.     {  
    10.         x=xx;  
    11.         y=yy;  
    12.         cout<<"构造函数被调用"<<endl;  
    13.     }  
    14.     point(point &p);//拷贝构造函数，参数是对象的引用  
    15.     ~point(){cout<<"析构函数被调用"<<endl;}  
    16.     int get_x(){return x;}//方法  
    17.     int get_y(){return y;}  
    18. };  
    19.   
    20. point::point(point &p)  
    21. {  
    22.     x=p.x;//将对象p的变相赋值给当前成员变量。  
    23.     y=p.y;  
    24.     cout<<"拷贝构造函数被调用"<<endl;  
    25. }  
    26.   
    27. void f(point p)  
    28. {  
    29.     cout<<p.get_x()<<"  "<<p.get_y()<<endl;  
    30. }  
    31.   
    32. point g()//返回类型是point  
    33. {  
    34.     point a(7,33);  
    35.     return a;  
    36. }  
    37.   
    38. void main()  
    39. {  
    40.     point a(15,22);  
    41.     point b(a);//构造一个对象，使用拷贝构造函数。  
    42.     cout<<b.get_x()<<"  "<<b.get_y()<<endl;  
    43.     f(b);  
    44.     b=g();  
    45.     cout<<b.get_x()<<"  "<<b.get_y()<<endl;  
    46. }  

    4.2运行结果

    4.3结果解析
    构造函数被调用 //point a(15,22);
    拷贝构造函数被调用 //point b(a);拷贝构造函数的第一种调用情况：用类的一个已知的对象去初始化该类的另一个对象时
    15 22 //cout<<b.get_x()<<" "<<b.get_y()<<endl;
    拷贝构造函数被调用 //f(b);拷贝构造函数的第二种调用情况：函数的形参是类的对象，调用函数进行形参和实参的结合时
    15 22 //void f(point p)函数输出对象b的成员
    析构函数被调用 //f(b);析构函数的第一种调用情况：在函数体内定义的对象，当函数执行结束时，该对象所在类的析构函数会被自动调用
    构造函数被调用 //b=g();的函数体内point a(7,33);创建对象a
    拷贝构造函数被调用 //b=g();拷贝构造函数的第三种调用情况，拷贝a的值赋给b：函数的返回值是类的对象，函数执行完返回调用者
    析构函数被调用 //拷贝构造函数对应的析构函数
    析构函数被调用 //b=g();的函数体内对象a析构
    7 33
    析构函数被调用 //主函数体b对象的析构
    析构函数被调用 //主函数体a对象的析构

    5.实例2

    5.1代码

    [cpp] view plaincopy
     
    1. #include <iostream>  
    2. using namespace std;  
    3. //基类  
    4. class CPerson  
    5. {  
    6.     char *name;        //姓名  
    7.     int age;            //年龄  
    8.     char *add;        //地址  
    9. public:  
    10.     CPerson(){cout<<"constructor - CPerson! "<<endl;}  
    11.     ~CPerson(){cout<<"deconstructor - CPerson! "<<endl;}  
    12. };  
    13.   
    14. //派生类(学生类)  
    15. class CStudent : public CPerson  
    16. {  
    17.     char *depart;    //学生所在的系  
    18.     int grade;        //年级  
    19. public:  
    20.     CStudent(){cout<<"constructor - CStudent! "<<endl;}  
    21.     ~CStudent(){cout<<"deconstructor - CStudent! "<<endl;}  
    22. };  
    23.   
    24. //派生类(教师类)  
    25. //class CTeacher : public CPerson//继承CPerson类，两层结构  
    26. class CTeacher : public CStudent//继承CStudent类，三层结构  
    27. {  
    28.     char *major;    //教师专业  
    29.     float salary;    //教师的工资  
    30. public:  
    31.     CTeacher(){cout<<"constructor - CTeacher! "<<endl;}  
    32.     ~CTeacher(){cout<<"deconstructor - CTeacher! "<<endl;}  
    33. };  
    34.   
    35. //实验主程序  
    36. void main()  
    37. {  
    38.     //CPerson person;  
    39.     //CStudent student;  
    40.     CTeacher teacher;  
    41. }  

    5.2运行结果

    5.3说明

    在实例2中，CPerson是CStudent的父类，而CStudent又是CTeacher的父类，那么在创建CTeacher对象的时候，首先调用基类也就是CPerson的构造函数，然后按照层级，一层一层下来。
     
     
     

    1、构造函数和析构函数为什么没有返回值？

    构造函数和析构函数是两个非常特殊的函数：它们没有返回值。这与返回值为void的函数显然不同，后者虽然也不返回任何值，但还可以让它做点别的事情，而构造函数和析构函数则不允许。在程序中创建和消除一个对象的行为非常特殊，就像出生和死亡，而且总是由编译器来调用这些函数以确保它们被执行。如果它们有返回值，要么编译器必须知道如何处理返回值，要么就只能由客户程序员自己来显式的调用构造函数与析构函数，这样一来，安全性就被人破坏了。另外，析构函数不带任何参数，因为析构不需任何选项。

    如果允许构造函数有返回值，在某此情况下，会引起歧义。如下两个例子

    复制代码
    class C
{
public:
    C(): x(0) {    }
    C(int i): x(i) {   }

private:
    int x;
};
    复制代码

    如果C的构造函数可以有返回值，比如int：int C():x(0) { return 1; } //1表示构造成功，0表示失败
    那么下列代码会发生什么事呢？
    C c = C();  //此时c.x == 1！！！
    很明显，C()调用了C的无参数构造函数。该构造函数返回int值1。恰好C有一个但参数构造函数C(int i)。于是，混乱来了。按照C++的规定，C c = C();是用默认构造函数创建一个临时对象，并用这个临时对象初始化c。此时，c.x的值应该是0。但是，如果C::C()有返回值，并且返回了1（为了表示成功），则C++会用1去初始化c，即调用但参数构造函数C::C(int i)。得到的c.x便会是1。于是，语义产生了歧义。使得C++原本已经非常复杂的语法，进一步混乱不堪。

    构造函数的调用之所以不设返回值，是因为构造函数的特殊性决定的。从基本语义角度来讲，构造函数返回的应当是所构造的对象。否则，我们将无法使用临时对象：
    void f(int a) {...}  //(1)
    void f(const C& a) {...} //(2)
    f(C()); //(3)，究竟调用谁？
    对于(3)，我们希望调用的是(2)，但如果C::C()有int类型的返回值，那么究竟是调(1)好呢，还是调用(2)好呢。于是，我们的重载体系，乃至整个的语法体系都会崩溃。
    这里的核心是表达式的类型。目前，表达式C()的类型是类C。但如果C::C()有返回类型R，那么表达式C()的类型应当是R，而不是C，于是便会引发上述的类型问题。

    2、显式调用构造函数和析构函数

    复制代码
    #include <iostream>
using namespace std;

class MyClass
{
public:
    MyClass()
    {
        cout << "Constructors" << endl;
    }

    ~MyClass()
    {
        cout << "Destructors" << endl;
    }
};

int main()
{
    MyClass* pMyClass =  new MyClass;
    pMyClass->~MyClass();
    delete pMyClass;

    return 0;
}
    复制代码

    结果：
    Constructors
    Destructors    //这个是显示调用的析构函数
    Destructors    //这个是delete调用的析构函数

    这有什么用？有时候，在对象的生命周期结束前，想先结束这个对象的时候就会派上用场了。直接调用析构函数并不释放对象所在的内存。
    由此想到的： 
    new的时候，其实做了三件事，一是：调用::operator new分配所需内存。二是：调用构造函数。三是：返回指向新分配并构造的对象的指针。
    delete的时候，做了两件事，一是：调用析构函数，二是：调用::operator delete释放内存。

    所以推测构造函数也是可以显式调用的。做个实验：
    int main()
    {
        MyClass* pMyClass = (MyClass*)malloc(sizeof(MyClass));
        pMyClass->MyClass();
        // …
    }

    编译pMyClass->MyClass()出错：
    error C2273: 'function-style cast' : illegal as right side of '->'operator
    它以为MyClass是这个类型。

    解决办法有两个：
    第一：pMyClass->MyClass::MyClass();
    第二：new(pMyClass) MyClass();
    第二种用法涉及C++ placement new 的用法。参考：http://www.cnblogs.com/luxiaoxun/archive/2012/08/10/2631812.html

    显示调用构造函数有什么用？

    有时候，你可能由于效率考虑要用到malloc去给类对象分配内存，因为malloc是不调用构造函数的，所以这个时候会派上用场了。
    另外下面也是可以的，虽然内置类型没有构造函数。
    int* i = (int*)malloc(sizeof(int));
    new (i) int();

    3、拷贝（复制）构造函数为什么不能用值传递

    当你尝试着把拷贝构造函数写成值传递的时候，会发现编译都通不过，错误信息如下：
    error: invalid constructor; you probably meant 'S (const S&)' （大致意思是：无效的构造函数，你应该写成。。。）
    当编译错误的时候你就开始纠结了，为什么拷贝构造函数一定要使用引用传递呢，我上网查找了许多资料，大家的意思基本上都是说如果用值传递的话可能会产生死循环。编译器可能基于这样的原因不允许出现值传递的拷贝构造函数，也有可能是C++标准是这样规定的。

    如果真是产生死循环这个原因的话，应该是这样子的：

    复制代码
    class S
{
public:
    S(int x):a(x){ }
    S(const S st) //拷贝构造函数
    {
        a = st.a;
    }
private:
    int a;
};

int main()
{
    S s1(2);
    S s2(s1);
    return 0;
}
    复制代码

    当给s2初始化的时候调用了s2的拷贝构造函数，由于是值传递，系统会给形参st重新申请一段空间，然后调用自身的拷贝构造函数把s1的数据成员的值传给st。当调用自身的拷贝构造函数的时候又因为是值传递，所以...
    也就是说，只要调用拷贝构造函数，就会重新申请一段空间，只要重新申请一段空间，就会调用拷贝构造函数，这样一直下去就形成了一个死循环。所以拷贝构造函数一定不能是值传递。

    4、构造函数/析构函数抛出异常的问题

    构造函数抛出异常：
        1.不建议在构造函数中抛出异常；
        2.构造函数抛出异常时，析构函数将不会被执行；
    C++仅仅能删除被完全构造的对象（fully contructed objects），只有一个对象的构造函数完全运行完毕，这个对象才能被完全地构造。对象中的每个数据成员应该清理自己，如果构造函数抛出异常，对象的析构函数将不会运行。如果你的对象需要撤销一些已经做了的动作（如分配了内存，打开了一个文件，或者锁定了某个信号量），这些需要被撤销的动作必须被对象内部的一个数据成员记住处理。

    析构函数抛出异常：
        在有两种情况下会调用析构函数。第一种是在正常情况下删除一个对象，例如对象超出了作用域或被显式地delete。第二种是异常传递的堆栈辗转开解（stack-unwinding）过程中，由异常处理系统删除一个对象。
    在上述两种情况下，调用析构函数时异常可能处于激活状态也可能没有处于激活状态。遗憾的是没有办法在析构函数内部区分出这两种情况。因此在写析构函数时你必须保守地假设有异常被激活，因为如果在一个异常被激活的同时，析构函数也抛出异常，并导致程序控制权转移到析构函数外，C++将调用terminate函数。这个函数的作用正如其名字所表示的：它终止你程序的运行，而且是立即终止，甚至连局部对象都没有被释放。
    概括如下：
        1.析构函数不应该抛出异常；
        2.当析构函数中会有一些可能发生异常时，那么就必须要把这种可能发生的异常完全封装在析构函数内部，决不能让它抛出函数之外；
        3.当处理另一个异常过程中，不要从析构函数抛出异常；

        在构造函数和析构函数中防止资源泄漏的好方法就是使用smart point（智能指针），C++ STL提供了类模板auto_ptr，用auto_ptr对象代替原始指针，你将不再为堆对象不能被删除而担心，即使在抛出异常时，对象也能被及时删除。因为auto_ptr的析构函数使用的是单对象形式的delete，而不是delete []，所以auto_ptr不能用于指向对象数组的指针。当复制 auto_ptr 对象或者将它的值赋给其他 auto_ptr 对象的时候，将基础对象的所有权从原来的 auto_ptr 对象转给副本，原来的 auto_ptr 对象重置为未绑定状态。因此，不能将 auto_ptrs 存储在标准库容器类型中。如果要将智能指针作为STL容器的元素，可以使用Boost库里的shared_ptr。
  • 相关阅读:
    磁盘管理之磁盘组成
    用户管理
    定时任务
    虚拟机安装centos6.9
    linux的文件属性与文件权限
    linux磁盘容量不足
    正则表达式与特殊符号
    linux三剑客与正则案例
    借用父构造函数继承属性
    myeclipse常用快捷键
  • 原文地址：https://www.cnblogs.com/Vae1990Silence/p/4320519.html
Copyright © 2020-2023  润新知