C++11 列表初始化都做了什么？

类的成员变量的初始化细节

首先，来看两个问题：

• 类的构造函数中，成员变量的列表初始化是如何实现的？
• 为什么列表初始化效率上优于在构造函数中为成员变量赋值？

（后文中，将 “在构造函数中为成员变量赋值” 简称为 “构内赋值”。）

这两个问题从何而来

通常，当你搜索为什么列表初始化优于构内赋值时，基本上所有的博文都会告诉你：“列表初始化使得成员变量在被定义时绑定初值；而在构造函数内赋值，成员变量会先在定义时被初始化为0，然后再被赋值为指定的初值。”总之，意思是，列表初始化相比于构内赋值少了一次对内存的写入。至于这样的说法是否正确？为什么会这样？列表初始化和构内赋值的实现细节是什么样的？很少有人分析。所以，本着“实践出真知”的道理，我们在这本篇博文中做了一些列的实验，并详细的讲述了为什么初始化列表由于构内赋值？。

列表初始化 和 构内赋值 的实现细节

首先，先将提出的两个问题回答一下：

• 类的列表初始化是通过成员变量的拷贝构造函数实现的。
• 列表初始化相比于构内赋值，减少了一半的函数调用，减少了一半的内存写入。

列表初始化和构内赋值的具体的流程图如下：

构内赋值 的实现细节

构内赋值分为两步实现：

• 调用各级成员的默认构造函数
• 调用各级成员的赋值函数

首先，我们来解释一下什么是“各级成员”？如下，类 A 中包含类型为 B 的成员变量 b，而 B 类型还可能包含类型为 C 的成员变量 c，如此递推。直至递推到基础类型（比如 int）。对于类 A 而言，b, c, d ... 就是它的各级成员。

class C{
    D d;
};

class B{
    C c;
};

class A{
    B b;
};

我们通过如下代码来测试构内赋值是如何实现的：

#include<iostream>

class Test0{
    int a;
public:
    Test0():a(0){
        std::cout<< "0默认构造\n";
    }
    Test0(const Test0& t1):a(t1.a){
        std::cout<< "0拷贝构造\n";
    }
    Test0(Test0&& t1):a(t1.a){
        std::cout<< "0移动构造\n";
    }
    void operator= (const Test0& t1){
        std::cout<< "0赋值函数\n";
        a = t1.a;
    }
};

class Test1{
    Test0 t;
public:
    Test1(){
        std::cout<< "1默认构造\n";
    }
    Test1(const Test1& t1):t(t1.t){
        std::cout<< "1拷贝构造\n";
    }
    Test1(Test1&& t1):t(t1.t){
        std::cout<< "1移动构造\n";
    }
    void operator= (const Test1& t1){
        std::cout<< "1赋值函数\n";
        t = t1.t;
    }
};

class Test2{
private:
    Test1 t1;
public:
    Test2(const Test1& t1){
        std::cout<< "2构造\n";
        this->t1 = t1;
    }
};

int main(){
    Test1 t1;       \\ main 函数第一行代码
    std::cout<< "---------------\n";
    Test2 t2(t1);   \\ main 函数第三行代码
}

在上面的代码中，我们定义了三个类，并依次包含，最底层的类 Test0 包含了一个基础类型 int。在 main 函数中，我们首先默认构造了一个 Test1 类型的对象 t1，而后将 t1 传入到 Test2 的构造函数中。Test2 的构造函数，是通过构内赋值实现的。我们运行上述代码，结果如下：

0默认构造
1默认构造
---------------
0默认构造
1默认构造
2构造
1赋值函数
0赋值函数

可以看到，main 函数的第一行代码通过默认构造函数构建对象 t1，从输出的第 1、2 行可以看出，t1 及其各级成员的构造函数自下而上的运行，即：int 的默认构造 -> Test0 的默认构造 -> Test1 的默认构造。默认构造函数，会定义变量，并初始化为 0。

main 函数的第三行我们定义变量 t2，将 main 函数第一行定义的 t1 传入其构造函数。从输出的第 4、5、6 行可以看出，t2 的成员变量 t1 首先经过了默认构造，然后才进入到 t2 的构造函数中。而后在 t2 的构造函数中，我们将 main 函数第一行定义的 t1 赋值给 t2 的成员变量 t1。从输出的 7、8 行可以看出，这个赋值操作自上而下的调用了成员的赋值函数，即： Test1 的赋值函数 -> Test0 的赋值函数 -> int 的赋值函数。

至此完成了构内赋值。整个过程的资源分析如下：

• 调用了各级成员的默认构造
• 向基础类型成员的内存中写入 0
• 调用了各级成员的赋值函数
• 向基础类型成员的内存中写入初值

列表初始化的实现细节

我们通过如下代码来观察列表初始化的实现细节：

#include<iostream>

class Test0{
    int a;
public:
    Test0():a(0){
        std::cout<< "0默认构造\n";
    }
    Test0(const Test0& t1):a(t1.a){
        std::cout<< "0拷贝构造\n";
    }
    Test0(Test0&& t1):a(t1.a){
        std::cout<< "0移动构造\n";
    }
    void operator= (const Test0& t1){
        std::cout<< "0赋值函数\n";
        a = t1.a;
    }
};

class Test1{
    Test0 t;
public:
    Test1(){
        std::cout<< "1默认构造\n";
    }
    Test1(const Test1& t1):t(t1.t){
        std::cout<< "1拷贝构造\n";
    }
    Test1(Test1&& t1):t(t1.t){
        std::cout<< "1移动构造\n";
    }
    void operator= (const Test1& t1){
        std::cout<< "1赋值函数\n";
        t = t1.t;
    }
};

class Test2{
private:
    Test1 t1;
public:
    Test2(const Test1& t1):t1(t1){
        std::cout<< "2构造\n";
    }
};

int main(){
    Test1 t1;
    std::cout<< "---------------\n";
    Test2 t2(t1);
}

相比于构内赋值的实现细节中的代码，我们将 Test2 的构造函数改为列表初始化。代码的运行结果如下：

0默认构造
1默认构造
---------------
0拷贝构造
1拷贝构造
2构造

观察输出的 4，5 行，列表初始化通过调用各级成员的拷贝构造函数来完成。这种调用是自下而上的，即：int 的拷贝构造 -> Test0 的拷贝构造 -> Test1 的拷贝构造。基础类型的成员经历了一次内存写入。

观察输出的 4, 5, 6 行，列表初始化在进入构造函数的函数体之前完成。

列表初始化的资源分析如下：

• 调用了各级成员的拷贝构造函数
• 向基础类型成员的内存中写入初值

列表初始化 与 构内赋值 所用资源比较

构内赋值的资源分析如下：

• 调用了各级成员的默认构造
• 向基础类型成员的内存中写入 0
• 调用了各级成员的赋值函数
• 向基础类型成员的内存中写入初值

列表初始化的资源分析如下：

• 调用了各级成员的拷贝构造函数
• 向基础类型成员的内存中写入初值

可见，列表初始化比构内赋值减少了一半的资源调用和一半的内存写入。因此列表初始化由于构内赋值。

看来，大多数博文中说的不完全对，他们只说对了内存，却没有分析函数的调用次数。