两个特别的构造函数

-无参构造函数

 没有参数的构造函数：

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

-拷贝构造函数

 参数为const class_name & 的构造函数 （当前类对象的引用）：

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

实例一：

 1 #include <stdio.h>
 2 
 3 class Test
 4 {
 5 private:
 6     int i;
 7     int j;
 8 public:
 9     int getI()
10     {
11         return i;
12     }
13     int getJ()
14     {
15         return j;
16     }
17     /*Test(const Test& t)
18     {
19         i = t.i;
20         j = t.j;
21     }
22     Test()
23     {
24     }*/
25 };
26 
27 int main()
28 {
29     Test t1;
30     Test t2 = t1;
31     
32     printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());
33     printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());
34     
35     return 0;
36 }

拷贝构造函数意义：

1.兼容C语言的初始化方式；

2.初始化行为能够符合预期的逻辑；

浅拷贝：

拷贝后对象的物理状态相同；

深拷贝：

拷贝后对象的逻辑状态相同。

编译器提供的拷贝函数只进行浅拷贝。（简单的复制工作）

 

 1 #include <stdio.h>
 2 
 3 class Test
 4 {
 5 private:
 6     int i;
 7     int j;
 8     int* p;
 9 public:
10     int getI()
11     {
12         return i;
13     }
14     int getJ()
15     {
16         return j;
17     }
18     int* getP()
19     {
20         return p;
21     }
22     Test(const Test& t)
23     {
24         i = t.i;
25         j = t.j;
26         p = new int;
27         
28         *p = *t.p;
29     }
30     Test(int v)
31     {
32         i = 1;
33         j = 2;
34         p = new int;
35         
36         *p = v;
37     }
38     void free()
39     {
40         delete p;
41     }
42 };
43 
44 int main()
45 {
46     Test t1(3);
47     Test t2(t1);
48     
49     printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP());
50     printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP());
51     
52     t1.free();
53     t2.free();
54     
55     return 0;
56 }