大括号之谜:C++的列表初始化语法解析
转载: https://segmentfault.com/a/1190000039362151
摘要:有朋友在使用std::array时发现一个奇怪的问题:当元素类型是复合类型时,编译通不过。
有朋友在使用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::arrayS 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]:
没有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}}}; // OKMyArray<S, 3> b{{1, 2}, {3, 4}, {5, 6}}; // 同样OKreturn 0;
}
当使用std::initializer_list的构造函数来初始化时,无论初始化列表外层是一层还是两层大括号,都能初始化成功,而且a和b的内容完全一样。
这又是为什么?难道std::initializer_list也支持大括号省略?
这里要提一件趣事:**《Effective Modern C++》**这本书在讲解对象初始化方法时,举了这么一个例子[2]:
class Widget {
public:Widget(); // default ctorWidget(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 Ctorn"; }X(std::initializer_list<T> il){std::cout << "il.size() = " << il.size() << 'n';}
};int main()
{X<DefCtor> a0({}); // il.size = 0X<DefCtor> b0{{}}; // il.size = 1X<DeletedDefCtor> a2({}); // il.size = 0// X<DeletedDefCtor> b2{{}}; // error! attempt to use deleted constructorX<NoDefCtor> a1({}); // il.size = 0X<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),并且传入含有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**的构造函数。对于这个类型,初始化时允许使用几层大括号呢?下面的初始化语句有哪些可以成功?分别是为什么?
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++11列表初始化
列表初始化: 1.旧语法中定义了初始化的几种不同形式,如下: int data = 0; //赋值初始化 int data = {0}; //花括号初始化 int data(0); //构造初始化 i ...
- 现代C++新特性 列表初始化
文字版PDF文档链接:现代C++新特性(文字版)-C++文档类资源-CSDN下载 1.回顾变量初始化 在介绍列表初始化之前,让我们先回顾一下初始化变量的传统方法.其中常见的是使用括号和等号在变量声明时 ...
- 【 C++11 】列表初始化、声明、范围for、STL中一些变化
目录 1.C++11简介 2.统一的列表初始化 { }初始化 initializer_list容器 3.声明 auto decltype nullptr 4.范围for 5.STL中一些变化 1.C+ ...
- 变量之--列表初始化和结构化绑定
变量之(变长)列表初始化 关键词 std::initializer_list 解释 在 C++98/03 中的对象初始化方法有很多种,这无疑增大了学习难度.这中情况在C++11中终于得到解决. 先看看 ...
- C++11 就地初始化与列表初始化
文章目录 1.就地初始化 1.1 简介 1.2 就地初始化与初始化列表的先后顺序 2.列表初始化 参考文献 1.就地初始化 1.1 简介 在 C++11 之前,只能对结构体或类的静态常量成员就地初始化 ...
- 就地初始化与列表初始化
1.就地初始化 在 C++11 之前,只能对结构体或类的静态常量成员就地初始化,其他的不行. class C { private:static const int a=10; // yesint ...
- [C++11新特性](24)列表初始化,右值引用,可变参数模板,lambda表达式,包装器
文章目录 列表初始化 {}初始化 initializer_list auto.nullptr.范围for decltype STL的变化 右值引用 简介 移动构造与移动赋值 完美转发 新的类功能 可变 ...
- C++11 列表初始化(list_initialization)
一 列表初始化 定义:从花括号初始化器列表初始化对象. 语法: // 直接列表初始化 T object { arg1, arg2, ... }; (1) T { arg1, arg2, ... } ( ...
- C++列表初始化容器
initializer_list是一个模板类,可能你已经用过它了但不知道而已,比如下面的代码就用了 #include <iostream> #include <vector>i ...
最新文章
- atm java代码_用JAVA制作简单的ATM的代码 求教
- 报名 | 智进未来:AI在医疗健康领域的应用、挑战及发展趋势
- 面试小结之Elasticsearch篇
- 发布一个原创的基于Ajax的通用(组合)查询
- 第三章 Models详解
- ABB 机器人 通信指令(人机对话):
- slope one 推荐算法python 代码_协同推荐算法实践之Slope One的介绍(转)
- CSS中的偏僻知识点
- D-S证据理论基本概念
- $.getJSON无法对外部变量进行赋值的问题
- 百度网盘卸载后,无法重新安装,说电脑中文件没有删除干净
- iOS蓝牙连接打印机,打印小票
- 超级AI买家阿里巴巴
- 黑客黑手伸向微博微信手机成网络钓鱼主要渠道
- luogu P5234 [JSOI2012]越狱老虎桥
- PBS环境------qsub, qstat, qdel
- MySQL数据库 第4章:数据库设计
- 下列关于python运算符的使用描述正确的是_以下关于 Python 字符串的描述中,正确的是( )...
- Ubuntu无法上网问题解决
- 向上取整、向下取整与四舍五入(易理解版)
热门文章
- 指针结构体函数-事实上能够这样具体理解
- JavaScript中eval()函数
- Angular浅入深出系列 - 写在前面
- 【C++】考虑virtual函数以外的其他选择
- 【转载】MongoDB基本操作
- VC++ 6.0 与VS2008 C++ DEBUG工具(Windows)介绍
- python email模块详解_python模块之email: 电子邮件编码解码 (一、解码邮件)
- python中分支结构包括哪些_python中的分支结构
- Flask 第三方组件之 script
- PHP中的语法特点小结