从初始化列表和构造函数谈C++的初始化机制

综合而言，C++中类的初始化操作有四个部分组成：

1.初始化列表：所有类非静态数据成员都可以在这里初始化，

        所有类静态数据成员都不能在这里初始化

2.构造函数体：对于类非静态数据成员：

            const型成员不能在这里初始化

            引用型成员不能在这里初始化


            没有默认构造函数的成员不能在这里初始化


        对于类静态数据成员：


            可以在这里修改可修改的静态成员，但静态成员必须已经在类外部初始化

3.类外初始化：除一个特例外，所有类static数据成员必须在这里初始化，

        特例是类static const int数据成员可以在这里初始化，也可以在成员的声明处初始化

4.类中声明时直接赋值：类static const int数据成员可以选在这里初始化。

直接罗列这样的规则，是我国大多数教科书的展开方式，记得经典的三部曲吗？

（1）定义

（2）定理

（3）例题

至于来龙去脉就只能靠我们这些学子的悟性了。何其苦载！事实证明需要理清

一些定理和思想的来龙去脉往往需要比这个定理更加广阔的知识和视野，让学生拿

着空洞的课本靠领悟？（不要意思，又吐槽了）

让我们从一段简单的代码开始：

[cpp] view plain copy
01.class A {
02. const int x;
03.public:
04. A() {
05. this->x = 1; /* Error! */
06. }
07.};

对很多人而言，这是什么直观写法，为什么就错了呢？其实这本质上相当于写：

[cpp] view plain copy
01.const int x;
02.x = 1;

所以我们只能按如下方式声明其初始化：

[cpp] view plain copy
01.class A {
02. const int x;
03.public:
04. A() : x(1) {
05. }
06.};

再来看一段简单的代码：

[html] view plain copy
01.class A {
02. int &x;
03.public:
04. A(int k) {
05. this->x = k; /* Error! */
06. }
07.};

同理这这本质上相当于写：

[cpp] view plain copy
01.int &x;
02.x = k;

所以我们只能按如下方式声明其初始化：

[cpp] view plain copy
01.class A {
02. const int x;
03.public:
04. A(int k) : x(k) {
05. }
06.};

有了上面两个简单例子作为引子，我们开始进一步讨论C++初始化的全过程。

其实我相信很多人还是怀着这样一些疑问“写在初始化列表里就相当于int &x=k;吗？”

且让我们来看看C++类的初始化的全过程：

（1）静态成员初始化阶段：所有类的静态成员应该都是在这个阶段初始化的。

注意初始化的顺序，就是操作语句的顺序，例如你有一个Test类：

[cpp] view plain copy
01.int Test::x = 2;
02.int Test::y = 3;

   需要注意的是2点，一是初始化语句不再需要static关键字，二是执行顺序就是

语句的顺序，这里是先初始化t1,再初始化t2。执行顺序的问题在静态成员是类的时候

就关系到构造函数的调用顺序了。另外需要注意的是，这些静态成员的初始化在任何具

体实例被创建前就已经完成了。

（2）实例初始化列表工作阶段：
需要说的是，在用户使用new或者其他方法开始构建实例的时候，第一步首先是向

操作系统申请内存，初始化列表是在申请成功后才开始工作的。

然后，根据非静态成员的声明顺序开始执行如下操作：

1.如果该成员没有出现在初始化列表中：

  1）如果是内置非const且非引用类型，不设定初值

  2）如果是const类型，报错，必须在这里给定初值

  3）如果是引用类型，报错，必须在这里给定初值

  4）如果是class类型，就调用默认构造函数，进行初始化操作

2.如果该成员出现在初始化列表中：

  1）如果是内置类型，就按初始化列表指定的值设定初值
  2）如果是const类型，就按初始化列表指定的值设定初值

  3）如果是引用类型，就按初始化列表指定的值设定初值

  4）如果是class类型，就调用初始化列表指定的构造函数进行初始化操作

（3）计算阶段：

根据构造函数的函数体进行赋值操作，或者修改操作，


在这里，静态和非静态数据都可以赋值和修改

下面用一段代码来测试这个过程：

[cpp] view plain copy
01.class Test1 { /用于测试Test2中含有没有默认构造函数的成员时的情况/
02.
03.public:
04.
05. int i;
06.
07. Test1(int a): i(a){} /这就取消了Test1的默认构造函数/
08.
09.};
10.
11.
12.
13.class Test2 {
14.
15.public:
16.
17. int a; //int a = 1;Error:不允许数据成员初始值设定项
18.
19. const int b;
20.
21. static int c;
22.
23. static const int d = 4;//正确，这样赋值也是可以的,也可以选在类声明外进行赋值
24.
25. //但是如果不赋值，则程序中没有使用d不出错，使用了就会有link error
26.
27. //无法解析的外部命令
28.
29. //static const float ff = 4.0; Error:只有静态常量整形数据成员才可以在类中初始化
30.
31.
32.
33. int &e;
34.
35. const int &f;
36.
37. static int &g;
38.
39. static const int &h;
40.
41. //static const int &h = x_h; Error:只有静态常量整形数据成员才可以在类中初始化
42.
43.
44.
45. Test1 t1;
46.
47. const Test1 t2;
48.
49. static Test1 t3;
50.
51. const static Test1 t4;
52.
53.
54.
55. Test2(int b, int e, int f, Test1 t1, Test1 t2)
56.
57. : b(b),
58.
59. //d(4), Error: d不是类的非静态成员或基类
60.
61. e(e),//如果没有这句，Error:Test2:e没有提供初始化值
62.
63. f(f),
64.
65. t1(t1),//如果没有这句，Error:Test1没有默认构造函数
66.
67. t2(t2)
68.
69. {
70.
71. a = 1;
72.
73. //b = 2; //Error:表达式必须是可修改的左值，b是左值，不能修改
74.
75. c = 3;
76.
77. //d = 4; //Error:表达式必须是可修改的左值，d是左值，但不能修改
78.
79. }
80.
81.};
82.
83.//int Test2::a = 1; //Error:非静态数据成员不能在其类的外部定义
84.
85.//int Test2::b = 2; //Error:非静态数据成员不能在其类的外部定义
86.
87.int Test2::c = 3; //如果没有这句，会出现无法解析的外部符号public:static int A::c
88.
89.//int Test2::d = 4; //Error: int与声明const int不兼容
90.
91.//int const Test2::d = 4; //和在类声明里面直接写赋值等价
92.
93.int x_g = 5; /这个全局变量主要用户后续的静态成员赋值/
94.
95.int x_h = 6; /这个全局变量主要用户后续的静态成员赋值/
96.
97.Test1 x_t3(7);/这个全局变量主要用户后续的静态成员赋值/
98.
99.Test1 x_t4(8);/这个全局变量主要用户后续的静态成员赋值/
100.
101.
102.int& Test2::g = x_g;
103.
104.const int& Test2::h = x_h;
105.
106.Test1 Test2::t3 = x_t3;
107.
108.const Test1 Test2::t4 = x_t4;

前面讲了这么多具体的细节，我个人建议按如下简化规则来记忆：

（1）所有static成员变量在类外初始化（不管它是const，是引用，还是没默认构造函数的对象）

（2）普通成员变量，是const,是引用，是没默认构造函数的，必须在初始化列表初始化

（3）普通成员变量，需要复杂运算的初始化变量，应该在构造函数内初始化，否则尽量在

 初始化列表中初始化。

另外补充2个小点：

（1）初始化列表的使用可能提高性能

[cpp] view plain copy
01.class Test3 {
02.
03.public:
04.
05. int a;
06.
07. Test3() {
08.
09. a = 0;
10.
11. puts(“Test3 constructor”);
12.
13. }
14.
15. Test3(Test3 &t3) {
16.
17. this->a = t3.a;
18.
19. puts(“Test3 copy constructor”);
20.
21. }
22.
23. Test3& operator=(Test3 &t) {
24.
25. puts(“Test3 assign operator”);
26.
27. this->a = t.a;
28.
29. return *this;
30.
31. }
32.
33.
34.
35. ~Test3() { }
36.
37.};
38.
39.
40.
41.class Test4 {
42.
43.public:
44.
45. Test3 t3;
46.
47. //Test4( Test3 &t3) : t3(t3) { //这种方式和下面的方式有相同的效果，不同的效率
48.
49. //}
50.
51.
52. Test4( Test3 &t3) {
53.
54. this->t3 = t3;
55.
56. };
57.
58.};

（2）成员是按照他们在类中出现的顺序进行初始化的，而不是按照他们在初始化列表出现的顺序初始化的

参考如下代码

[cpp] view plain copy
01.struct foo
02.{
03. int i ;
04. int j ;
05. foo(int x):i(x), j(i){}; // ok, 先初始化i，后初始化j
06.};

再看下面的代码

[cpp] view plain copy
01.struct foo
02.{
03. int i ;
04. int j ;
05. foo(int x):j(x), i(j){} // i值未定义
06.};

这里i的值是未定义的因为虽然j在初始化列表里面出现在i前面，但是i先于j定义，所以先初始化i，但i由j初始化，此时j尚未初始化，所以导致i的值未定义。所以，一个好的习惯是，按照成员定义的顺序进行初始化。也就是说相当于实际执行顺序是：

i(j);

j(x);

所以会出现错误。

其中为什么要使用初始化列表是因为：

1.常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面；

2.引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面；

1. 没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化。