- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章解析之C++的列表初始化语法由作者收集整理,如果你对这篇文章有兴趣,记得点赞哟.
先从std::array的内部实现说起。为了让std::array表现得像原生数组,C++中的std::array与其他STL容器有很大区别——std::array没有定义任何构造函数,而且所有内部数据成员都是public的。这使得std::array成为一个聚合(aggregate).
对聚合的定义,在每个C++版本中有少许的区别,这里简单总结下C++17中定义:一个class或struct类型,当它满足以下条件时,称为一个聚合[1]:
直观的看,聚合常常对应着只包含数据的struct类型,即常说的POD类型。另外,原生数组类型也都是聚合.
聚合初始化可以用大括号列表。一般大括号内的元素与聚合的元素一一对应,并且大括号的嵌套也和聚合类型嵌套关系一致。在C语言中,我们常见到这样的struct初始化语句.
解了上面的原理,就容易理解为什么std::array的初始化在多一层大括号时可以成功了——因为std::array内部的唯一元素是一个原生数组,所以有两层嵌套关系。下面展示一个自定义的MyArray类型,它的数据结构和std::array几乎一样,初始化方法也类似:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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元素类型是简单类型时,省掉一层大括号也没问题?——这就涉及聚合初始化的另一个特点:大括号省略.
C++允许在聚合的内部成员仍然是聚合时,省掉一层或多层大括号。当有大括号被省略时,编译器会按照内层聚合所含的元素个数进行依次填充.
下面的代码虽然不常见,但是是合法的。虽然二维数组初始化只用了一层大括号,但因为大括号省略特性,编译器会依次用所有元素填充内层数组——上一个填满后再填下一个.
1
|
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内部有两个数组的话,它还会在填完上一个数组后依次填下一个.
这也解释了为什么省掉内层大括号,复杂类型也可以编译成功:
1
|
std::array<S, 3> a3{1, 2, 3, 4, 5, 6};
// 内层不加括号,编译成功
|
因为S也是个聚合类型,所以这里省略了两层大括号。编译期按照下面的顺序依次填充元素:数组0号元素的S::x、数组0号元素的S::y、数组1号元素的S::x、数组1号元素的S::y…… 。
虽然大括号可以省略,但是一旦用户显式的写出了大括号,那么必须要和这一层的元素个数严格对应。因此下面的写法会报错:
1
|
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有个自定义的构造函数,省掉大括号就行不通了:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
// 聚合
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的构造函数与空构造函数的微妙区别.
上面讲的所有规则,都只对聚合初始化有效。如果我们给MyArray类型加上一个接受std::initializer_list的构造函数,情况又不一样了:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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]:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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++》作为一本经典图书,读者众多。很快就有读者发现了这个错误,之后Scott Meyers将这个错误的阐述放在了书籍的勘误表中[3].
Scott Meyers还邀请读者们和他一起研究正确的规则到底是什么,最后,他们把结论写在了一篇文章里[4]。文章通过3种具有不同构造函数的自定义类型,来揭示std::initializer_list匹配时的微妙差异。代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
#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?
问题的原因在于:当使用大括号初始化来调用构造函数时,编译器会进行两次尝试:
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的例子,现在我们可以分析出两种初始化分别是在哪一步成功的:
1
2
|
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>的构造函数。对于这个类型,初始化时允许使用几层大括号呢?下面的初始化语句有哪些可以成功?分别是为什么?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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;
}
|
以上就是解析之C++的列表初始化语法的详细内容,更多关于C++的列表初始化语法的资料请关注我其它相关文章! 。
原文链接:https://www.cnblogs.com/huaweiyun/p/14498448.html 。
最后此篇关于解析之C++的列表初始化语法的文章就讲到这里了,如果你想了解更多关于解析之C++的列表初始化语法的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
在此处回答的另一个问题中,我发现了以下 JavaScript代码: function _dom_trackActiveElement(evt) { if (evt && evt.target)
if (A == 0) OR (B == 0) 怎么说? 最佳答案 只是为了讽刺: if (A === 0 || B === 0) 关于语法,我们在Stack Overflow上找到一个类似的问题:
var ret = [] ,xresult = document.evaluate(exp, rootEl, null, X
我一直在寻找一些类似于下例的 JavaScript。有人可以解释一下吗,因为我以前从未见过这样编写的 JavaScript。 “SomethingHere”和冒号代表什么?我习惯于看到函数 myFun
这是我的程序: delimiter // drop procedure if exists migContactToActor; create procedure migContactToActor(
我遇到了一个问题。我一直在使用 gcc 编译/汇编我的 C 代码一段时间,并且习惯了阅读 Intel 汇编语法。我在生成程序集文件时使用了 -masm=intel 标志。 但是最近因为公司迁移,拿到了
自上而下和自下而上语法有什么区别?举个例子就太好了。 最佳答案 首先,语法本身不是自上而下或自下而上的,解析器是(尽管有些语法可以被其中一个解析,但不能被另一个解析)。 从实践的角度来看,主要区别在于
我知道这是草率的代码,但它是: display dialog ("Start Screensaver. Please type: matrix, coffee, waffles, star, wate
这个问题已经有答案了: Giving name to a loop (6 个回答) 已关闭 8 年前。 我见过这个字符在 C# 中使用,就像 Java 中的扩展一样,但最近我在代码中发现了这个 loo
我正在尝试编写一个函数来检查字符串是否为回文,但我认为在使用字符串指针时存在一些错误。这段代码有什么问题? #include #include #define MAX 1000 int IsPalin
所以在this question我询问了一些 Javascript 是如何被压缩的。问题已得到解答,但以下片段让我非常困惑,以至于我不得不问另一个问题。在这里: for (Y = 0; $ = 'zx
假设我有一个接受这些参数的函数。 int create(Ptr * p,void * (*insert)(void *, void *)) { //return something later } 结
这个问题已经有答案了: Bitwise '&' operator (6 个回答) 已关闭 5 年前。 我在代码中找到了这个,但我从未遇到过像 & 这样的事情,仅 && if ((code & 1) =
我在处理继承类及其中的构造函数和方法的语法时遇到了问题。 我想实现一个类日期和一个子类 date_ISO,它们将按特定顺序设置给定的日、月、年,并通过一种方法将其写入字符串。我觉得我的基类日期工作正常
我正在尝试通过存储过程填充表,如下所示: SET @resultsCount = (SELECT COUNT(*) FROM tableA); SET @i = 0; WHILE @i THEN
谁能解释一下下面代码中的“<<”? mysql test<
刚刚开始学习 MySQL,这是一个菜鸟问题,也是我在 StackOverflow 上的第一个问题。 假设我有 12 个订单状态,我想从其中的 5 个中选择总计。我会使用: SELECT SUM(tot
我的编程背景是在学校学过一点Java。由于某些原因,JavaScript 语法往往让我感到困惑。下面的 JavaScript 代码是一种我不知道如何构成的语法模式: foo.ready = funct
我正在阅读 javascript 源代码,并且我以前没有编写过 javascript。我对它的一些语法感到困惑。 $(function () { window.onload=function
我什至不知道如何命名我想要的东西。那么让我举个例子来解释一下。 虽然火狐使用textContent,但其他浏览器支持innerText属性。顺便说一句,如果我使用了错误的术语,请纠正我。无论如何,到目
我是一名优秀的程序员,十分优秀!