引言

变量初始化的工作，要是不细想，可能会觉得是一件挺简单的事儿，例如int a = 100;。但在 C++ 的世界里，谁也不敢说哪件事是简单的，要是写成int a = {100};，不知道你有没有见过？

其实后一种写法是列表初始化方法，是 C++11 标准里定义的，它的结果也和前一种一样。我们在下文会对列表初始化的用法、原理，以及如何避坑进行详细讨论。

如果这个变量int a是出现在类的声明中，那又有什么新花样对它进行默认初始化呢？我们就从类的非静态成员默认初始化说起吧。

非静态成员默认初始化

这要从一个痛点说起。

在 C++11 标准之前，如果一个类的非静态数据成员较多，那么用初始化列表方式，编写构造函数时就会比较痛苦。如下例所示，会发现这几乎就是在穷举各种情况。

class OneInit {
    public:
        OneInit() : x(0), y(false), z("init") {}
        OneInit(int x) : x(x), y(false), z("init") {}
        OneInit(bool y) : x(0), y(y), z("init") {}
        OneInit(const string &z) : x(0), y(0), z(z) {}

    private:
        int x;
        bool y;
        string z;
};

这还仅是举个栗子，实际情况里一个类里十来个成员是常有的事，真要这样写默认初始化，费劲不说，还容易出错。

C++11 提供了新的初始化方法，就是在类内声明处，直接对非静态成员赋值即可。经过改写，看下新的版本：

class OneInit {
    public:
        OneInit() {}
        OneInit(int x) : x(x) {}
        OneInit(bool y) : y(y) {}
        OneInit(const string &z) : z(z) {}

    private:
        int x = 0;
        bool y = false;
        string z{"init"}; //这是列表初始化方法，下节会具体讲述
};

是不是简化得多了，是不是有一种清爽感扑面而来？构造函数里，只关注你想初始化的成员就好，所有默认值都可以放在声明处，一次性解决。

虽然方便，但仍有两点注意事项，以免掉坑。

• 第一，不要使用括号()对非静态数据成员进行初始化；
• 第二，不要使用auto关键字声明和初始化非静态数据成员。

其实你真用了上面的方法，编译也会报错，只是要知道错在哪里。

列表初始化

在介绍列表初始化之前，我们先回顾一下已有的两种初始化方式：直接初始化和拷贝初始化。

直接初始化一般使用括号方式，将初始值赋予变量。而拷贝初始化，则是使用等号对变量进行初始化。

示例代码如下：

class OneInit {
    public:
        OneInit(int x) {}
};

int main() {
    OneInit one(100); // 直接初始化
    OneInit one2 = 101; // 拷贝初始化
    OneInit *one3 = new OneInit(102); // 思考题：这是哪种初始化类型？
}

需要注意的是，拷贝初始化的等号并不是赋值的含义，而是隐式调用构造函数。如果在构造函数前加上explicit关键字，则编译会失败。explicit的作用就是强制构造函数必须显式调用。

那么，我们来看一下 C++11 中新增的列表初始化的方法，它使用花括号{}对变量进行初始化。列表初始化也有直接和拷贝两种初始化类型。

还是用代码说话：

class OneInit {
    public:
        OneInit(int x, string y) {}
};

int main() {
    OneInit one{100, "init"}; // 直接初始化
    OneInit one2 = {101, "init"}; // 拷贝初始化
    OneInit *one3 = new OneInit{102, "init"}; // 直接初始化，知道上面思考题的答案了吧
}

上述代码在构造函数中增加了一个string类型参数，以方便大家看到，在多参数的情况下，如何编写列表初始化方法。

乍一看，这似乎和括号初始化方式差别不大，但它有一个妙用，就是在使用函数返回对象的时候，可以用列表初始化方式进行多参数的隐式构造，看代码来体会一下：

class OneInit {
    public:
        OneInit(int x, string y) {}
};

OneInit get_object() {
    return {103, "init"}; // 简化了生成对象的过程
}

int main() {
    OneInit one = get_object();
}

相信大家对列表初始化的规则已经了解，下面我们讲一个高阶应用。

容器初始化

我们对于数组可以方便地以int array[] = {1, 2, 3}；这样的方法来初始化。但是对于 STL 库中的众多容器，以前却没什么好办法，只能写一个循环不断地追加值。

现在借助于列表初始化，我们也可以做到像数组一样初始化容器对象了。

int main() {
    int array1[]{1, 2, 3};
    int array2[] = {1, 2, 3};
    vector<int> v1{1, 2, 3};
    vector<int> v2 = {1, 2, 3};
    list<int> l1{1, 2, 3};
    list<int> l2 = {1, 2, 3};
    map<string, int> m1{ {"one", 1}, {"two", 2}, {"three", 3} };
    map<string, int> m2 = { {"one", 1}, {"two", 2}, {"three", 3} };
}

STL 容器对象的初始化，看起来也如丝般光滑了。这个实现离不开一个前提，就是容器类要支持std::initializer_list为形参的构造函数。

std::initializer_list是一个支持begin, end, size成员函数的类模板。编译器首先将花括号的内容构造为一个std::initializer_list对象，然后匹配容器类的构造函数，只要形参是std::initializer_list类型，那么执行相应的构造函数。

在构造函数中对begin, end范围内的数据进行循环，就实现了多参数元素的初始化。说起来真不复杂，各位有心的完全可以自己定义一个类，然后支持std::initializer_list形参的构造函数，也能实现自有的列表初始化方法了。

不知道你注意到没有，map 的初始化有点与众不同，对于多参数的元素，似乎只管嵌套就完了。如果深究的话，你会发现内层元素{"one", 1}其实是隐式调用了std::pair构造函数，而外层则是走的std::initializer_list方式。

注意事项

列表初始化容易掉坑的地方，就是在隐式缩窄转换上。例如int a = 10240; char b = a;中，变量 b 的初始化就发生了隐式缩窄，信息发生了丢失。这种问题编译时有可能警告都不会有，所以要千万小心。

要避免这样的问题，需要知道四条隐式缩窄规则：

1. 从浮点类型转换到整数类型；
2. 从long double转换到long或float。或从double转换到float；
3. 从整数类型或非强枚举类型，转换到浮点类型；
4. 从整数类型或非强枚举类型，转换到不能代表所有原始类型值的整数类型。

以下代码是错误示例，请仔细看：

int main() {
    int a = 10240;
    double b = 99.9;
    int  c = {3.0}; // 对应规则1
    float d = {b};  // 对应规则2
    float e = {a};  // 对应规则3
    char f = {a};   // 对应规则4
}

结语

没想到一个变量初始化，也能整出这么多说法来。即使是一件看起来应该简单的事情，在 C++ 里面也能不断挖出坑来。所以谁也不敢说自己是 C++ 高手，那是分分钟被打脸。

不管怎样，让我们记住本文最重要的三个点，方便自己以后写代码吧：

• 类的非静态成员，可以在声明处直接初始化；
• 使用列表初始化方法，简化多参数构造函数隐式执行；
• STL 容器对象，可直接使用列表初始化方法。

参考资料：

谢丙堃 现代C++语言核心特性解析 人民邮电出版社