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 = 0
gt.j = 0
t1.i = 1404627760
t1.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;
}

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