对象的构造 | 易学教程

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

在栈上创建对象时，成员变量初始值为随机值
在堆上创建对象时，成员对象初始值为随机值
在静态存储区创建对象时，成员变量初始为0值
一般而言，对象都需要一个确定的初始状态
解决方案：在类中提供一个public的initialize函数，对象创建后立即调用initialize函数进行初始化

class Test
{
private:
    int i;
    int j;
public:
    void initialize(){i = 0;j = 0;}
    int getI(){return i;}
    int getJ(){return j;}
};

存在的问题

initialize只是一个普通的函数，必须显示调用
如果未调用initialize函数，运行的结果是不确定的

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

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

 1 #include <stdio.h>
 2 class Test
 3 {
 4 private:
 5      int i;
 6      int j;
 7 public:
 8      int getI(){ return i; }
 9      int getJ(){ return j; }
10      //构造函数
11      Test()
12      {
13            i = 1;
14            j = 2;
15      }
16 };
17 Test a;
18 int main()
19 {
20      printf("a.i=%d\n",a.getI());
21      printf("a.j=%d\n", a.getJ());
22      Test b;
23      printf("b.i=%d\n", b.getI());
24      printf("b.j=%d\n", b.getJ());
25      Test *pt = new Test;
26      printf("pt->i=%d\n",pt->getI());
27      printf("pt->j=%d\n",pt->getJ());
28      delete pt;
29      return 0;
30 }
31  
32 运行结果：
33 a.i=1
34 a.j=2
35 b.i=1
36 b.j=2
37 pt->i=1
38 pt->j=2
39 请按任意键继续. . .

带有参数的构造函数

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

1 class Test
2 {
3 public:
4     //带参构造函数
5     Test(int v)
6     {
7             //use v to initialize member
8     }
9 };

友情提示

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

1 //定义对象并调用构造构造函数
2 Test t;
3 int main
4 {
5     //告诉编译器存在名为t的Test对象
6     extern Test t;
7     return 0;
8 }

构造函数的自动调用

 1 #include <stdio.h>
 2 class Test
 3 {
 4 public:
 5      Test()
 6      {
 7            printf("Test()\n");
 8      }
 9      Test(int v)
10      {
11            printf("Test(int v),v=%d\n",v);
12      }
13 };
14 int main()
15 {
16      Test t;      // 调用Test()
17      Test t1(1);  // 调用Test(int v)
18      Test t2 = 2; // 调用Test(int v)
19      t = t2;      //赋值操作，初始化才会调用构造函数
20      int i(100);  //初始化，（初始化和赋值是两个概念，不等价）
21      printf("i=%d\n",i);
22      return 0;
23 }
24 运行结果：
25 Test()
26 Test(int v),v=1
27 Test(int v),v=2
28 i=100
29 请按任意键继续. . .

构造函数的调用

一般情况下，构造函数在对象定义时被自动调用
一些特殊情况下，需要手工调用构造函数
如何创建一个对象数组？？？

 1 #include <stdio.h>
 2 class Test
 3 {
 4 public:
 5      Test()
 6      {
 7            printf("Test()\n");
 8      }
 9      Test(int v)
10      {
11            printf("Test(int v),v=%d\n",v);
12      }
13 };
14 int main()
15 {
16      Test t;             // 调用Test()
17      Test t1(1);         // 调用Test(int v)
18      Test t2 = 2;       // 调用Test(int v)
19      t =  t2;          //赋值操作，初始化才会调用构造函数
20      int i(100);       //初始化，（初始化和赋值是两个概念，不等价）
21      printf("i=%d\n",i);
22      Test Ta[3] = {Test(),Test(1),Test(2)}; //手动调用构造函数
23      Test ta = Test(3);
24      return 0;
25 }
26

两个特殊的构造函数

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

 1 #include <stdio.h>
 2 class Test
 3 {
 4 private:
 5      int i;
 6      int j;
 7 public:
 8      int getI()
 9      {
10            return i;
11      }
12      int getJ()
13      {
14            return j;
15      }
16      //编译器会在没有提供一个构造函数时，才会提供无参构造函数
17      Test()
18      {
19      }
20      //拷贝构造函数，当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制。
21      Test(const Test&t)
22      {
23            i = t.i;
24            j = t.j;
25      }
26 };
27 int main()
28 {
29      Test T1;
30      Test T2 = T1;
31      printf("T1.I=%d,T1.J=%d\n",T1.getI(),T1.getJ());
32      printf("T2.I=%d,T2.J=%d\n", T2.getI(), T2.getJ());
33      return 0;
34 }

拷贝构造函数的意义

兼容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()
    //{
 
 
    //}
    Test(int v)
    {
        i = 1;
        j = 2;
        p = new int;
        *p = v;
    }
    //拷贝构造函数，当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制。
    Test(const Test&t)
    {
        i = t.i;
        j = t.j;
        p = new int;
        *p = *t.p;
    }
    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());
    return 0;
}