这个是我们组的每日一例，主要目的是想通过老队员指导新队员，同时又可以巩固大家的cpp知识。我们组长说，项目做完之后这些东东可以整理出书了～
这一份是我写的，所以就发布出来啦！～这个还算写得比较详细吧！
Chapter One - 调用构造函数对成员变量进行构造、初始化 在类构造的时候，对于类成员变量的构造貌似可以在构造函数中完成，那为什么还需要成员初始化表呢？
我们来看看这样的情况：
1 /* programme 1 */
2 class Base
3 {
4 public:
5 Base(int val)
6 : i(val) //这里为什么要放在成员初始化表呢？
7 {
8 //i = val??
9 }
10 ~Base(){}
11
12 private:
13 int i;
14 };
15
16 class UseBase
17 {
18 Base b;
19 public:
20 UseBase(){} //没有用Base的构造函数
21 ~UseBase(){}
22 };
23
24 int main()
25 {
26 return 0;
27 };
28 /* end of programme 1 */
程序出现这样的错误：error C2512: 'Base' : no appropriate default constructor available，在UseBase中Base没有被合理地初始化。
1 /* programme 2 */
2
3 //
4
5 class UseBase
6 {
7 Base b;
8 public:
9 UseBase() : b(0){} //可以编译通过
10 ~UseBase(){}
11 };
12
13 //
14
15 /* end of programme 2 */
由此可以看出成员初始化列表的一个要点，调用构造函数对成员变量进行构造、初始化。对于内置成员变量(int、double等等，个人理解为C语言中就已经有的类型，详细信息参见Primer)而言没有明显的问题，但对于非内置成员变量而言，即便编程者没有在成员初始化表中显示调用构造函数，编译器也会隐式地调用默认构造函数。所谓“默认构造函数”就是指"$classname$(void)"这样的形式。上面的例子就是因为这个原因而编译失败的，Base没有提供默认构造函数。也就是说，需要特殊构造的类必须在成员初始化列表进行构造、初始化。
而如果有默认构造函数，是否就可以在成员初始化表中置之不理呢？答案是否定的，这涉及到效率问题。（以下程序可以中的Base完全可以用string类型来取代，但为了方便调试方式查看，所以重新编写了Base。）
1 /* programme 3 */
2
3 class Base
4 {
5 public:
6 Base(void)
7 : i(0)
8 {
9 // breakpoint 1
10 }
11 // 赋值操作符重载
12 Base& operator= ( const int val )
13 {
14 i = val;// breakpoint 2
15 return *this;
16 }
17
18 ~Base(){}
19
20 private:
21 int i;
22 };
23 class UseBase
24 {
25 Base b;
26 public:
27 UseBase()
28 //: b(0)
29 {
30 b = 3;// breakpoint 3
31 }
32 ~UseBase(){}
33 };
34
35 int main()
36 {
37 UseBase ub;
38 return 0;
39 };
40 /* end of programme 3 */
breakpoint的顺序为1-3-2，这说明UseBase中的Base既进行了默认构造，之后又进行了赋值，原本可以通过一个构造函数完成的操作，现在分成了两个步骤，效率降低了。
Chapter Two - 派生类的成员初始化表 在派生类的成员初始化表中，可以调用基类的构造函数来初始化其基类成分。
1 /* programme 4 */
2 #include <iostream>
3 using namespace std;
4 class Base
5 {
6 public:
7 Base( const int val )
8 : i(val)
9 {
10 }
11
12 Base& operator= ( const int val )
13 {
14 i = val;
15 return *this;
16 }
17
18 virtual ~Base(){}
19
20 void print() const
21 {
22 cout << "val: " << i << endl;
23 }
24
25 private:
26 int i;
27 };
28
29 class Derived : public Base
30 {
31 public:
32 Derived( const int val )
33 : Base(val)
34 {}
35 };
36
37 int main()
38 {
39 Derived d(1);
40 d.print();
41 getchar();
42 return 0;
43 };
44 /* end of programme 4 */
一个小错误，很多人可能会犯的：
1 /* programme 5 */
2 //
3
4 class Derived : public Base
5 {
6 public:
7 Derived( const int val )
8 //: Base(val)
9 {
10 Base(val);
11 }
12 };
13
14 //
15 /* end of programme 5 */
在构造函数体内直接调用基类的构造函数，但这样是不能完成对基类成分的初始化的。这个语句的意义是创建一个临时的Base对象。
Chapter Three - 初始化const、引用成员 利用成员初始化表能够初始化const、引用成员，这在构造函数体内是无法做到的。因为一般情况下，const、引用的对象在声明的时候就要同时将值或对象绑定到一起。
1 /* programme 6 */
2 #include <iostream>
3 #include <string>
4 using namespace std;
5 class dummy
6 {
7 const int ci;
8 string& szStr;
9
10 public:
11 dummy(const int i, string &sz)
12 : ci(i)
13 , szStr(sz)
14 {}
15
16 void printi()
17 {
18 cout << "const int: " << ci << endl;
19 }
20
21 void printsz()
22 {
23 cout << "string&: " << szStr << endl;
24 }
25
26 void setsz(string &sz)
27 {
28 szStr = sz;
29 }
30 };
31
32 int main()
33 {
34 string _4ref("hello");
35 dummy d(10, _4ref);
36 d.printi();
37 d.printsz();
38 cout << endl;
39 d.setsz( string("goodbye") );
40 d.printsz();
41 cout << "_4ref: " << _4ref << endl;
42 getchar();
43 return 0;
44 };
45 /* end of programme 6 */
输出结果
const int: 10
string&: hello
string&: goodbye
_4ref: goodbye