C++解析(11)：对象的构造

0.目录

1.对象的初始化

2.构造函数

3.无参构造函数与拷贝构造函数

4.小结

1.对象的初始化

对象中成员变量的初始值是多少？

下面的类定义中成员变量i和j的初始值是什么？

从程序设计的角度，对象只是变量，因此：

• 在栈上创建对象时，成员变量初始为随机值
• 在堆上创建对象时，成员变量初始为随机值
• 在静态存储区创建对象时，成员变量初始为0值

C++中可以定义与类名相同的特殊成员函数，这种特殊的成员函数叫做构造函数。

• 构造函数没有任何返回类型的声明
• 构造函数在对象定义时自动被调用

2.构造函数

带有参数的构造函数：

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

友情提醒——对象定义和对象声明不同：

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

构造函数的自动调用：

构造函数的调用：

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

如何创建一个对象数组？

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

为了指定初始值，需要手工调用构造函数。

运行结果为：

[root@bogon Desktop]# g++ test.cpp
[root@bogon Desktop]# ./a.out
Test()
Test(int v), v = 1
Test(int v), v = 2
ta[0].getValue() = 0
ta[1].getValue() = 1
ta[2].getValue() = 2
Test(int v), v = 100
t.getValue() = 100

3.无参构造函数与拷贝构造函数

两个特殊的构造函数：

• 无参构造函数——没有参数的构造函数
• 拷贝构造函数——参数为const class_name& 的构造函数

无参构造函数：当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空

拷贝构造函数：当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制

拷贝构造函数的意义：

• 兼容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\n", t1.getI(), t1.getJ());
    printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());

    printf("*t1.p = %d, t1.p = %p\n", *t1.getP(), t1.getP());
    printf("*t2.p = %d, t2.p = %p\n", *t2.getP(), t2.getP());

    t1.free();
    t2.free();

    return 0;
}

如果不进行深拷贝，采用默认的拷贝构造函数，那么t1.p和t2.p将指向同一片堆空间，因此这一片将被释放两次！

运行结果为：

[root@bogon Desktop]# g++ test.cpp
[root@bogon Desktop]# ./a.out
t1.i = 1, t1.j = 2
t2.i = 1, t2.j = 2
*t1.p = 3, t1.p = 0x2363010
*t2.p = 3, t2.p = 0x2363030

4.小结

• 每个对象在使用之前都应该初始化
• 类的构造函数用于对象的初始化
• 构造函数与类同名并且没有返回值
• 构造函数在对象定义时自动被调用
• 构造函数可以根据需要定义参数
• 构造函数之间可以存在重载关系
• 构造函数遵循C++中重载函数的规则
• 对象定义时会触发构造函数的调用
• 在一些情况下可以手动调用构造函数
• C++编译器会默认提供构造函数
• 无参构造函数用于定义对象的默认初始状态
• 拷贝构造函数在创建对象时拷贝对象的状态
• 对象的拷贝有浅拷贝和深拷贝两种方式
  1. 浅拷贝使得对象的物理状态相同
  2. 深拷贝使得对象的逻辑状态相同