11、不一样的C++系列--对象的构造

对象的初始化

---

先上一段代码：

#include <stdio.h>class Test{private:    int i;    int j;public:    int getI() { return i; }    int getJ() { return j; }};Test gt;int main(){    printf("gt.i = %d\n", gt.getI());    printf("gt.j = %d\n", gt.getJ());    Test t1;    printf("t1.i = %d\n", t1.getI());    printf("t1.j = %d\n", t1.getJ());    return 0;}

在上述代码中会打印什么呢？ 我这里直接放上运行结果；

gt.i = 0gt.j = 0t1.i = 1404627760t1.j = 32767

• 从程序设计的角度，对象只是变量，因为：
  
  • 在栈上创建对象时，成员变量初始为随机值
  • 在堆上创建对象时，成员变量初始为随机值
  • 在静态存储区创建对象时，成员变量初始为0值

一般而言，对象都需要一个确定的初始状态
解决方案：

（1）在类中提供一个public的initialize函数（2）对象创建后立即调用initialize函数进行初始化 class Test {    private:        int i;        int j;    public:        void initialize(){i = 0; j = 0;}        int getI()  {return i;}        int getJ()  {return j;} }

存在的问题：

（1）initialize只是一个普通函数，必须显示调用

（2）如果未调用initialize函数，运行结果是不确定的

构造函数

---

• C++中可以定义与类名相同的特殊成员函数

  • 这种特殊的成员函数叫做构造函数
  • 构造函数没有任何返回类型的声明
  • 构造函数在对象定义时自动被调用

• 带有参数的构造函数

  • 构造函数可以根据需要定义参数
  • 一个类中可以存在多个重载的构造函数
  • 构造函数的重载遵循C++重载的规则

例如：

class Test{    public:        Test(int v)        {            //use V to initialize member        }}

• 对象定义和对象声明不同
  
  • 对象定义 — 申请对象的空间并调用构造函数
  • 对象声明 — 告诉编译器存在这样一个对象

    Test t; //定义对象并调用构造函数    int main（）    {        //告诉编译器存在名为 t 的 Test 对象        extern Test t;        return 0;    }

• 构造函数的自动调用

    class Test    {        public:            Test() { }            Test(int v) { }    };    int main()    {        Test t;         //调用Test()        Test t1(1);     //调用Test(int v)        Test t2 = 1;    //调用Test(int v)        return 0;    }

• 构造函数的调用
  
  • 一般情况下，构造函数在对象定义时被自动调用
  • 一些特殊情况下，需要手工调用构造函数

#include <stdio.h>class Test{private:    int m_value;public:    Test()     {         printf("Test()\n");        m_value = 0;    }    Test(int v)     {         printf("Test(int v), v = %d\n", v);        m_value = v;    }    int getValue()    {        return m_value;    }};int main(){    //手工调用构造函数    Test ta[3] = {Test(), Test(1), Test(2)};          for(int i=0; i<3; i++)    {        printf("ta[%d].getValue() = %d\n", i , ta[i].getValue());    }    Test t = Test(100);    printf("t.getValue() = %d\n", t.getValue());    return 0;}

特殊的构造函数

---

• 两个特殊的构造函数
  
  • 无参构造函数 — 没有参数的构造函数
  • 拷贝构造函数 — 参数为const class_name& 的构造函数
• 无参构造函数
  
  • 当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空
• 拷贝构造函数
  
  • 当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制

#include <stdio.h>class Test{private:    int i;    int j;public:    int getI()    {        return i;    }    int getJ()    {        return j;    }    //拷贝构造函数    /*Test(const Test& t)     {     i = t.i;     j = t.j;     }     //构造函数     Test()     {     }*/};int main(){    Test t1;    Test t2 = t1;    printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());    printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());    return 0;}

拷贝构造函数

---

• 拷贝构造函数的意义（一）
  
  • 兼容C语言的初始化方式
  • 初始化行为能够符合预期的逻辑
• 拷贝构造函数的意义（二）
  
  • 浅拷贝 — 拷贝后对象的物理状态相同
  • 深拷贝 — 拷贝后对象的逻辑状态相同
• 编译器提供的拷贝构造函数只进行 浅拷贝 ！

举个例子：

#include <stdio.h>class Test{private:    int i;    int j;    int* p;public:    int getI()    {        return i;    }    int getJ()    {        return j;    }    int* getP()    {        return p;    }    //重写拷贝构造函数，形成深拷贝    Test(const Test& t)    {        i = t.i;        j = t.j;        p = new int;        *p = *t.p;    }    Test(int v)    {        i = 1;        j = 2;        p = new int;        *p = v;    }    void free()    {        delete p;    }};int main(){    Test t1(3);    Test t2(t1);    printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP());    printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP());    t1.free();    t2.free();    return 0;}

• 什么时候需要进行深拷贝？
  
  • 对象中有成员指代了系统中的资源
    
    • 成员指向了动态内存空间
    • 成员打开了外存中的文件
    • 成员使用了系统中的网络端口
    • …..
• 一般性原则
  
  • 自定义拷贝构造函数，必然需要实现深拷贝！！！