对象的初始化

先上一段代码：

#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;
}