为什么使用初始化列表会快一些？

查看下面两段代码:

// (1) class classA {...}; class classB { public: classB(classA a) {mA = a;} private: classA mA; }; 

// (2) class classA {...}; class classB { public: classB(classA a): mA(a) {} private: classA mA; }; 

初始化列表的效率要高。

首先把数据成员按类型分类

1. 内置数据类型，复合类型（指针，引用）
2. 用户定义类型（类类型）

分情况说明：

• 对于类型 1，在成员初始化列表和构造函数体内进行，在性能和结果上都是一样的
• 对于类型 2，结果上相同，但是性能上存在很大的差别

初始化列表，顾名思义，是对成员数据进行初始化，而不是赋值，赋值操作在构造函数体内！

好比:

classA a; classA b = a; 

和

classA a; classA b; b = a; 

的区别。

上述的代码 1 不够清晰，我们写成下面这样:

#include <iostream> using namespace std; class classA { public: classA() { cout << "classA()" << endl; } classA(const classA& a) { cout << "copy classA()" << endl; } ~classA() { cout << "~classA()" << endl; } classA& operator=(const classA& a) { cout << "operator=" << endl; return *this; } }; class classB { public: classB(classA a) : mA(a) {} private: classA mA; }; int main() { classA a; classB b(a); } 

// 打印如下: //1 classA() //2 copy classA() //3 copy classA() //4 ~classA() //5 ~classA() //6 ~classA() 

1. classA a; 调用默认构造函数构造 a 对象
2. classB(classA a) : mA(a) {}, classB 类的构造函数里的 classA a形参拷贝 1 声明的对象
3. classB(classA a) : mA(a) {}, 初始化列表拷贝 2 里的形参 a 的对象
4. 2 里的形参 a 析构
5. 1 里的 a 析构
6. 对象 b 里的 mA 析构

4，5，6 的析构顺序没有验证。

对于代码 2

#include <iostream> using namespace std; class classA { public: classA() { cout << "classA()" << endl; } classA(const classA& a) { cout << "copy classA()" << endl; } ~classA() { cout << "~classA()" << endl; } classA& operator=(const classA& a) { cout << "operator=" << endl; return *this; } }; class classB { public: classB(classA a) { mA = a; } private: classA mA; }; int main() { classA a; classB b(a); } 

// 打印如下: //1 classA() //2 copy classA() //3 classA() //4 operator= //5 ~classA() //6 ~classA() //7 ~classA() 

1. classA a; 调用默认构造函数构造 a 对象
2. classB(classA a) : mA(a) {}, classB 类的构造函数里的 classA a形参拷贝 1 声明的对象
3. 初始化列表进行初始化，调用默认构造函数
4. operator=, 函数体内赋值操作，把 2 里的 a 赋值给 mA
5. 2 里的形参 a 析构
6. 1 里的 a 析构
7. 对象 b 里的 mA 析构

代码 2 相对于代码 1，少了一次默认的构造函数。 代码 1 直接调用拷贝构造，代码 2 先调用默认构造，再调用赋值函数。

所有初始化列表要快一点！