有朋友在使用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> a1{{1, 2}, {3, 4}, {5, 6}};  // 原生数组的初始化写法,编译失败!
std::array<S, 3> a2{{{1, 2}, {3, 4}, {5, 6}}}; // 外层多一层括号,编译成功
std::array<S, 3> a3{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]:

  1. 没有privateprotected数据成员;
  2. 没有用户提供的构造函数(但是显式使用=default=delete声明的构造函数除外);
  3. 没有virtualprivate或者protected基类;
  4. 没有虚函数

直观的看,聚合常常对应着只包含数据的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的构造函数来初始化时,无论初始化列表外层是一层还是两层大括号,都能初始化成功,而且ab的内容完全一样。

这又是为什么?难道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的表现是容易理解的。但是b0b1的区别就很奇怪了:一模一样的初始化方法,为什么一个传入std::initializer_list的长度为1,另一个长度为0?

构造函数的两步尝试

问题的原因在于:当使用大括号初始化来调用构造函数时,编译器会进行两次尝试:

  1. 把整个大括号列表连同最外层大括号一起,作为构造函数的std::initializer_list参数,看看能不能匹配成功;
  2. 如果第一步失败了,则将大括号列表的成员作为构造函数的入参,看看能不能匹配成功。

对于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::tupletuple只有一个成员,是自定义类型SS定义有默认构造函数和接受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++的列表初始化语法解析》,原文作者:飞得乐。

点击关注,第一时间了解华为云新鲜技术~

大括号之谜:C++的列表初始化语法解析的更多相关文章

  1. 【ZZ】C++11之统一初始化语法 | 桃子的博客志

    C++11之统一初始化语法 | 桃子的博客志 https://taozj.net/201710/list-initialize.html 在当前新标准C++11的语法看来,变量合法的初始化器有如下形式 ...

  2. C++11常用特性介绍——列表初始化

    一.列表初始化 1)C++11以前,定义初始化的几种不同形式,如下: int data = 0;   //赋值初始化 int data = {0};   //花括号初始化 int data(0); / ...

  3. C++统一初始化语法(列表初始化)

    引言 要是世上不曾存在C++14和C++17该有多好!constexpr是好东西,但是让编译器开发者痛不欲生:新标准库的确好用,但改语法细节未必是明智之举,尤其是3年一次的频繁改动.C++带了太多历史 ...

  4. 列表初始化 分析initializer_list<T>的实现

    列表初始化(1)_统一初始化 1. 统一初始化(Uniform Initialization) (1)在C++11之前,很多程序员特别是初学者对如何初始化一个变量或对象的问题很容易出现困惑.因为可以用 ...

  5. C++ Union妙用(将列表初始化用于数组元素)

    Union是个不被注意的关键字,意为联合体,这是个诡异的名字.若不是为了继承C语言,它也不会出现在C++中(虽说,union在C++中得到了扩充,完成了接近类的功能).它的作用主要是节省内存空间,在嵌 ...

  6. C++比较特殊的构造函数和初始化语法

    C++的构造函数 看Qt创建的示例函数, 第一个构造函数就没看懂. 是这样的 Notepad::Notepad(QWidget *parent) : QMainWindow(parent), ui(n ...

  7. 列表初始化(list initialization)

    列表初始化啊就是大括号来初始化: 列表初始化的好处:

  8. 关于c++中结构体列表初始化,聚合问题

    聚合(aggregate) C++语法规定:不能使用初始值列表来初始化"非聚合(non-aggregate)"的对象.那么,什么才算是"聚合"呢?C++认为聚合 ...

  9. C语言标记化结构初始化语法

    C语言标记化结构初始化语法 (designated initializer),而且还是一个ISO标准. #include <stdio.h> #include <stdlib.h&g ...

随机推荐

  1. CodeForces - 1100E 二分+拓扑排序

    题意: 一个n个节点的有向图,节点标号从1到n,存在m条单向边.每条单向边有一个权值,代表翻转其方向所需的代价.求使图变成无环图,其中翻转的最大边权值最小的方案,以及该方案翻转的最大的边权. Inpu ...

  2. Codeforces Round #672 (Div. 2 B. Rock and Lever (位运算)

    题意:给你一组数,求有多少对\((i,j)\),使得\(a_{i}\)&\(a_{j}\ge a_{i}\ xor\ a_{j}\). 题解:对于任意两个数的二进制来说,他们的最高位要么相同要 ...

  3. Selenium刚玩一会儿,就感受了私人秘书的体验

    学习python的过程中,少不了接触第三方库,毕竟作为胶水语言python的强大之处也就是第三方库体量庞大,无疑大大增强了python的战斗力. 有时候想完成网页自动化操作,这时候Selenium进入 ...

  4. 编译安装MySQL 5.5.33

    环境要求: 主机名 IP地址 需要软件及版本 系统版本 mysql.mfyxw.com 192.168.80.135 Mysql5.5.33 5.5.33 1.设定主机名 hostnamectl se ...

  5. zzuli-2266 number

    题目描述 某人刚学习了数位DP,他在某天忽然思考如下问题: 给定n,问有多少数对<x, y>满足: x, y∈[1, n], x < y x, y中出现的[0, 9]的数码种类相同 ...

  6. ZOJ 3430 Detect the Virus(AC自动机 + 模拟)题解

    题意:问你主串有几种模式串.但是所有串都是加密的,先解码.解码过程为:先把串按照他给的映射表变成6位数二进制数,然后首尾衔接变成二进制长串,再8位8位取变成新的数,不够的补0.因为最多可能到255,所 ...

  7. Object Destructuring Assignment vs Object.assign

    Object Destructuring Assignment vs Object.assign // const params = Object.assign({}, this.$route.par ...

  8. IT-ebooks free download website & IT 电子书籍免费下载网站

    free ebooks of programming 1. http://www.it-ebooks.info/ http://www.it-ebooks-api.info/ 2. http://ww ...

  9. 微信小程序 UI 组件库

    微信小程序 UI 组件库 Vant Weapp 需要注意的是 package.json 和 node_modules 必须在 miniprogram 目录下 $ yarn add @vant/weap ...

  10. How to using PyPI publish a Python package

    How to using PyPI publish a Python package PyPI & Python package https://pypi.org/ main make a f ...