本文共 4085 字，大约阅读时间需要 13 分钟。
目录
初始化列表用于对类的数据成员进行初始化。成员列表在构造函数中进行初始化，跟在构造函数的冒号后面。
参考下面例子：
#include class Point{private: int x; int y;public: Point(int i = 0, int j = 0):x(i), y(j) {} /* 上面的初始化列表是可选的，因为也可以写成下面的形式: Point(int i = 0, int j = 0) { x = i; y = j; } */ int getX() const {return x;} int getY() const {return y;}};int main(){ Point t1(11, 22); std::cout<<"x = "< <<", "; std::cout<<"y = "<
输出：
x = 11, y = 22 上面代码是对初始化列表的简单演示。 x和y也能在构造函数体中进行初始化。
但是，在某些情形下，数据成员不能在构造函数中初始化，而只能使用初始化列表。
1.non-static const数据成员的初始化
非静态常量(non static const)数据成员必须使用初始化列表。
参考下面例子中的成员变量t。
#include using namespace std;class Test{ const int t;public: Test(int t):t(t) {} //必须使用初始化列表 int getT() { return t; }};int main(){ Test t1(111); cout<
运行输出：
111 2.引用成员的初始化
引用成员必须使用初始化列表。 参考下面例子中的t。
#include using namespace std;class Test{ int &t;public: Test(int &t):t(t) {} //必须使用初始化列表 int getT() { return t; }};int main(){ int x = 22; Test t1(x); cout< <<", "; x = 33; cout< <
输出：
22, 33 3.初始化没有默认构造函数的成员对象
下面例子中, 类'B' 的数据成员'a'是类'A'的一个对象, 并且'A'没有默认构造函数，则'B'必须使用初始化列表来对'a'进行初始化。
#include using namespace std;class A{ int i;public: A(int);};A::A(int arg){ i = arg; cout << "A's Constructor called: Value of i: " << i << endl;}// 类B包含A的一个对象class B{ A a;public: B(int);};B::B(int x) : a(x) //必须使用初始化列表{ cout << "B's Constructor called";}int main(){ B obj(10); return 0;}
输出：
A's Constructor called: Value of i: 10 B's Constructor called 如果类A既有默认构造函数，又有带参数的构造函数，当想要用默认构造函数来初始化'a'时，则B不一定需要使用初始化列表；
当想要用参数的构造函数来初始化'a'时，则B一定要使用初始化列表。
4.基类数据成员的初始化
与上面的第3条类似，如果想要带参数的构造函数初始化基类，则子类必须使用初始化列表。
#include class A{ int i;public: A(int);};A::A(int arg){ i = arg; std::cout << "A's Constructor called: Value of i: " << i << std::endl;}// Class B 继承自Class Aclass B : A{public: B(int);};B::B(int x) : A(x){ //必须使用初始化列表 std::cout << "B's Constructor called";}int main(){ B obj(10); return 0;}
运行结果：
A's Constructor called: Value of i: 10 B's Constructor called 5.当构造函数的参数名字与数据成员的名字相同时
如果构造函数的参数与数据成员的名字相同，则数据成员必须使用初始化列表，或者带this指针的方式，进行初始化。
参考下面程序中的参数'i'与数据成员'i'。
#include class A{ int i;public: A(int); int getI() const { return i; }};A::A(int i) : i(i) // 或者使用初始化列表，或者使用this指针{}/* 也可以写出下面代码 A::A(int i) { this->i = i; } */int main(){ A a(10); std::cout << a.getI(); return 0;}
输出：
10 6.性能原因
使用初始化列表的性能更好。参见下面例子：
#include class Type{public: Type() { std::cout << "constructor called\n"; } ~Type() { std::cout << "destructor called\n"; } Type(const Type & type) { std::cout << "copy constructor called\n"; } Type& operator=(const Type & type) { std::cout << "operator= called\n"; return *this; }};// 不使用初始化列表class MyClass{ Type variable;public: MyClass(Type a) //假设Type是一个定义了拷贝构造与赋值操作符的类 { variable = a; }};int main(){ Type type; MyClass mc(type); return 0;}
输出：
constructor called //main中的"Type type" copy constructor called //使用新建的对象type来创建MyClass构造函数中的参数a constructor called //MyClass的成员对象variable的构造 operator= called //MyClass构造函数中的"variable = a" destructor called //a的生命周期结束destructor called //mc析构，其中成员对象variable也会析构 destructor called //type生命周期结束 由上面可知道，编译器会遵循下面顺序来创建一个MyClass的对象：
1. 调用Type的拷贝构造函数来创建参数a。
2. 调用Type的构造函数来创建成员对象variable。
3. 调用Type的赋值操作符，修改成员对象variable。
variable = a;
4. 调用Type的析构函数，因为a的生命周期结束了。
如果MyClass的构造函数使用的是初始化列表，如下面例子所示：
// 使用初始化列表class MyClass { Type variable;public: MyClass(Type a):variable(a) { // 假设Type是一个定义了拷贝构造与赋值操作符的类 }}; 输出结果为：
constructor called copy constructor called copy constructor called destructor called destructor called destructor called 使用初始化列表后，编译器会遵循下面顺序：
1. 调用Type的拷贝构造函数来初始化参数a。
2. 调用Type的拷贝构造函数，在初始化列表中的使用参数a来对成员对象variable进行初始化。
3. 调用Type的析构函数，因为a的生命周期结束了。
总结：
由上面的这个对比例子可知，使用初始化列表少用了一个步骤。
即如果是在构造函数体中赋值，则需要copy constructor + constructor + assignment operator + destructor。
如果用初始化列表，则只需要copy constructor + copy constructor + destructor，少了一个调用赋值运算符的过程。
在真实的应用程序中，如果存在很多的成员数据，则多出的这一个拷贝过程，可能会消耗掉可观的性能。
转载地址：http://xqeji.baihongyu.com/