有朋友在使用std::array时发现一个奇怪的问题：当元素类型是复合类型时，编译通不过。
-
struct S {
-
int x;
-
int y;
-
};
-
-
int main()
-
{
-
int a1[
3]{
1,
2,
3};
// 简单类型，原生数组
-
std::
array<
int, 3> a2{
1,
2,
3};
// 简单类型，std::array
-
S a3[
3]{{
1,
2}, {
3,
4}, {
5,
6}};
// 复合类型，原生数组
-
std::
array<S, 3> a4{{
1,
2}, {
3,
4}, {
5,
6}};
// 复合类型，std::array，编译失败！
-
return
0;
-
}
按说std::array和原生数组的行为几乎是一样的，可为什么当元素类型不同时，初始化语法还会有差别？更蹊跷的是，如果多加一层括号，或者去掉内层的括号，都能让代码编译通过：
-
std::array<S,
3> a
1{{
1,
2}, {
3,
4}, {
5,
6}}; // 原生数组的初始化写法，编译失败！
-
std::array<S,
3> a
2{{{
1,
2}, {
3,
4}, {
5,
6}}}; // 外层多一层括号，编译成功
-
std::array<S,
3> a
3{
1,
2,
3,
4,
5,
6}; // 内层不加括号，编译成功
这篇文章会介绍这个问题的原理，以及正确的解决方式。
聚合初始化
先从std::array的内部实现说起。为了让std::array表现得像原生数组，C++中的std::array与其他STL容器有很大区别——std::array没有定义任何构造函数，而且所有内部数据成员都是public的。这使得std::array成为一个聚合（aggregate）。
对聚合的定义，在每个C++版本中有少许的区别，这里简单总结下C++17中定义：一个class或struct类型，当它满足以下条件时，称为一个聚合[1]：
- 没有private或protected数据成员；
- 没有用户提供的构造函数（但是显式使用=default或=delete声明的构造函数除外）；
- 没有virtual、private或者protected基类；
- 没有虚函数
直观的看，聚合常常对应着只包含数据的struct类型，即常说的POD类型。另外，原生数组类型也都是聚合。
聚合初始化可以用大括号列表。一般大括号内的元素与聚合的元素一一对应，并且大括号的嵌套也和聚合类型嵌套关系一致。在C语言中，我们常见到这样的struct初始化语句。
解了上面的原理，就容易理解为什么std::array的初始化在多一层大括号时可以成功了——因为std::array内部的唯一元素是一个原生数组，所以有两层嵌套关系。下面展示一个自定义的MyArray类型，它的数据结构和std::array几乎一样，初始化方法也类似：
-
struct S {
-
int x;
-
int y;
-
};
-
-
template<
typename T,
size_t N>
-
struct MyArray {
-
T data[N];
-
};
-
-
int main()
-
{
-
MyArray<
int,
3> a1{{
1,
2,
3}};
// 两层大括号
-
MyArray<S,
3> a2{{{
1,
2}, {
3,
4}, {
5,
6}}};
// 三层大括号
-
return
0;
-
}
在上面例子中，初始化列表的最外层大括号对应着MyArray，之后一层的大括号对应着数据成员data，再之后才是data中的元素。大括号的嵌套与类型间的嵌套完全一致。这才是std::array严格、完整的初始化大括号写法。
可是，为什么当std::array元素类型是简单类型时，省掉一层大括号也没问题？——这就涉及聚合初始化的另一个特点：大括号省略。
大括号省略（brace elision）
C++允许在聚合的内部成员仍然是聚合时，省掉一层或多层大括号。当有大括号被省略时，编译器会按照内层聚合所含的元素个数进行依次填充。
下面的代码虽然不常见，但是是合法的。虽然二维数组初始化只用了一层大括号，但因为大括号省略特性，编译器会依次用所有元素填充内层数组——上一个填满后再填下一个。
int a[3][2]{1, 2, 3, 4, 5, 6}; // 等同于{{1, 2}, {3, 4}, {5, 6}}知道了大括号省略后，就知道std::array初始化只用一层大括号的原理了：由于std::array的内部成员数组是一个聚合，当编译器看到{1,2,3}这样的列表时，会挨个把大括号内的元素填充给内部数组的元素。甚至，假设std::array内部有两个数组的话，它还会在填完上一个数组后依次填下一个。
这也解释了为什么省掉内层大括号，复杂类型也可以编译成功：
std::array<S, 3> a3{1, 2, 3, 4, 5, 6}; // 内层不加括号，编译成功因为S也是个聚合类型，所以这里省略了两层大括号。编译期按照下面的顺序依次填充元素：数组0号元素的S::x、数组0号元素的S::y、数组1号元素的S::x、数组1号元素的S::y……
虽然大括号可以省略，但是一旦用户显式的写出了大括号，那么必须要和这一层的元素个数严格对应。因此下面的写法会报错：
std::array<S, 3> a1{{1, 2}, {3, 4}, {5, 6}}; // 编译失败！编译器认为{1,2}对应std::array的内部数组，然后{3,4}对应std::array的下一个内部成员。可是std::array只有一个数据成员，于是报错：too many initializers for 'std::array<S, 3>'
需要注意的是，大括号省略只对聚合类型有效。如果S有个自定义的构造函数，省掉大括号就行不通了：
-
// 聚合
-
struct S1 {
-
S1() =
default;
-
int x;
-
int y;
-
};
-
-
std::
array<S1, 3> a1{
1,
2,
3,
4,
5,
6};
// OK
-
-
// 聚合
-
struct S2 {
-
S2() =
delete;
-
int x;
-
int y;
-
};
-
-
std::
array<S2, 3> a2{
1,
2,
3,
4,
5,
6};
// OK
-
-
// 非聚合，有用户提供的构造函数
-
struct S3 {
-
S3() {};
-
int x;
-
int y;
-
};
-
-
std::
array<S3, 3> a3{
1,
2,
3,
4,
5,
6};
// 编译失败！
这里可以看出=default的构造函数与空构造函数的微妙区别。
std::initializer_list的另一个故事
上面讲的所有规则，都只对聚合初始化有效。如果我们给MyArray类型加上一个接受std::initializer_list的构造函数，情况又不一样了：
-
struct S {
-
int x;
-
int y;
-
};
-
-
template<
typename T,
size_t N>
-
struct MyArray {
-
public:
-
MyArray(
std::
initializer_list<T> l)
-
{
-
std::copy(l.begin(), l.end(),
std::begin(data));
-
}
-
T data[N];
-
};
-
-
int main()
-
{
-
MyArray<S,
3> a{{{
1,
2}, {
3,
4}, {
5,
6}}};
// OK
-
MyArray<S,
3> b{{
1,
2}, {
3,
4}, {
5,
6}};
// 同样OK
-
return
0;
-
}
当使用std::initializer_list的构造函数来初始化时，无论初始化列表外层是一层还是两层大括号，都能初始化成功，而且a和b的内容完全一样。
这又是为什么？难道std::initializer_list也支持大括号省略？
这里要提一件趣事：《Effective Modern C++》这本书在讲解对象初始化方法时，举了这么一个例子[2]：
-
class Widget {
-
public:
-
Widget();
// default ctor
-
Widget(
std::
initializer_list<
int> il);
// std::initializer_list ctor
-
…
// no implicit conversion funcs
-
};
-
-
Widget w1;
// calls default ctor
-
Widget w2{};
// also calls default ctor
-
Widget w3();
// most vexing parse! declares a function!
-
-
Widget w4({});
// calls std::initializer_list ctor with empty list
-
Widget w5{{}};
// ditto <-注意！
然而，书里这段代码最后一行w5的注释却是个技术错误。这个w5的构造函数调用时并非像w4那样传入一个空的std::initializer_list，而是传入包含了一个元素的std::initializer_list。
即使像Scott Meyers这样的C++大牛，都会在大括号的语义上搞错，可见C++的相关规则充满着陷阱！
连《Effective Modern C++》都弄错了的规则
幸好，《Effective Modern C++》作为一本经典图书，读者众多。很快就有读者发现了这个错误，之后Scott Meyers将这个错误的阐述放在了书籍的勘误表中[3]。
Scott Meyers还邀请读者们和他一起研究正确的规则到底是什么，最后，他们把结论写在了一篇文章里[4]。文章通过3种具有不同构造函数的自定义类型，来揭示std::initializer_list匹配时的微妙差异。代码如下：
-
#include <iostream>
-
#include <initializer_list>
-
-
class DefCtor {
-
int x;
-
public:
-
DefCtor(){}
-
};
-
-
class DeletedDefCtor {
-
int x;
-
public:
-
DeletedDefCtor() =
delete;
-
};
-
-
class NoDefCtor {
-
int x;
-
public:
-
NoDefCtor(
int){}
-
};
-
-
template<
typename T>
-
class X {
-
public:
-
X() {
std::
cout <<
"Def Ctor\n"; }
-
-
X(
std::
initializer_list<T> il)
-
{
-
std::
cout <<
"il.size() = " << il.size() <<
'\n';
-
}
-
};
-
-
int main()
-
{
-
X<DefCtor> a0({});
// il.size = 0
-
X<DefCtor> b0{{}};
// il.size = 1
-
-
X<DeletedDefCtor> a2({});
// il.size = 0
-
// X<DeletedDefCtor> b2{{}}; // error! attempt to use deleted constructor
-
-
X<NoDefCtor> a1({});
// il.size = 0
-
X<NoDefCtor> b1{{}};
// il.size = 0
-
}
对于构造函数已被删除的非聚合类型，用{}初始化会触发编译错误，因此b2的表现是容易理解的。但是b0和b1的区别就很奇怪了：一模一样的初始化方法，为什么一个传入std::initializer_list的长度为1，另一个长度为0？
构造函数的两步尝试
问题的原因在于：当使用大括号初始化来调用构造函数时，编译器会进行两次尝试：
- 把整个大括号列表连同最外层大括号一起，作为构造函数的std::initializer_list参数，看看能不能匹配成功；
- 如果第一步失败了，则将大括号列表的成员作为构造函数的入参，看看能不能匹配成功。
对于b0{ {}}这样的表达式，可以直观理解第一步尝试是：b0({ {}})，也就是把{ {}}整体作为一个参数传给构造函数。对b0来说，这个匹配是能够成功的。因为DefCtor可以通过{}初始化，所以b0的初始化调用了X(std::initializer_list<T>)，并且传入含有1个成员的std::initializer_list作为入参。
对于b1{ {}}，编译器同样会先做第一步尝试，但是NoDefCtor不允许用{}初始化，所以第一步尝试会失败。接下来编译器做第二步尝试，将外层大括号剥掉，调用b1({})，发现可以成功，这时传入的是空的std::initializer_list。
再回头看之前MyArray的例子，现在我们可以分析出两种初始化分别是在哪一步成功的：
-
MyArray<S,
3> a{{{
1,
2}, {
3,
4}, {
5,
6}}}; // 在第二步，剥掉外层大括号后匹配成功
-
MyArray<S,
3> b{{
1,
2}, {
3,
4}, {
5,
6}}; // 第一步整个大括号列表匹配成功
综合小测试
到这里，大括号初始化在各种场景下的规则就都解析完了。不知道读者是否彻底掌握了？
不妨来试一试下面的小测试：这段代码里有一个仅含一个元素的std::array，其元素类型是std::tuple，tuple只有一个成员，是自定义类型S，S定义有默认构造函数和接受std::initializer_list<int>的构造函数。对于这个类型，初始化时允许使用几层大括号呢？下面的初始化语句有哪些可以成功？分别是为什么？
-
struct S {
-
S() =
default;
-
S(
std::
initializer_list<
int>) {}
-
};
-
-
int main()
-
{
-
using MyType =
std::
array<
std::tuple<S>,
1>;
-
MyType a{};
// 1层
-
MyType b{{}};
// 2层
-
MyType c{{{}}};
// 3层
-
MyType d{{{{}}}};
// 4层
-
MyType e{{{{{}}}}};
// 5层
-
MyType f{{{{{{}}}}}};
// 6层
-
MyType g{{{{{{{}}}}}}};
// 7层
-
return
0;
-
}
尾注
[1] https://en.cppreference.com/w/cpp/language/aggregate_initialization
[2] 位于书的 Item 7: Distinguish between () and {} when creating objects. 第55页
[3] https://www.aristeia.com/BookErrata/emc++-errata.html
[4] https://scottmeyers.blogspot.com/2016/11/help-me-sort-out-meaning-of-as.html
本文分享自华为云社区《大括号之谜——C++的列表初始化语法解析》，原文作者：飞得乐。
转载：https://blog.csdn.net/devcloud/article/details/114523118