低价备案域名购买,搜索引擎优化简称seo,腾讯短链接生成,开网络公司的小说转载#xff1a; https://segmentfault.com/a/1190000039362151 摘要#xff1a;有朋友在使用std::array时发现一个奇怪的问题#xff1a;当元素类型是复合类型时#xff0c;编译通不过。 有朋友在使用std::array时发现一个奇怪的问题#xff1a;当元素类型是复合类型时 https://segmentfault.com/a/1190000039362151 摘要有朋友在使用std::array时发现一个奇怪的问题当元素类型是复合类型时编译通不过。 有朋友在使用std::array时发现一个奇怪的问题当元素类型是复合类型时编译通不过。
struct S {int x;int y;
};int main()
{int a1[3]{1, 2, 3}; // 简单类型原生数组std::arrayint, 3 a2{1, 2, 3}; // 简单类型std::arrayS a3[3]{{1, 2}, {3, 4}, {5, 6}}; // 复合类型原生数组std::arrayS, 3 a4{{1, 2}, {3, 4}, {5, 6}}; // 复合类型std::array编译失败return 0;
}按说std::array和原生数组的行为几乎是一样的可为什么当元素类型不同时初始化语法还会有差别更蹊跷的是如果多加一层括号或者去掉内层的括号都能让代码编译通过
std::arrayS, 3 a1{{1, 2}, {3, 4}, {5, 6}}; // 原生数组的初始化写法编译失败
std::arrayS, 3 a2{{{1, 2}, {3, 4}, {5, 6}}}; // 外层多一层括号编译成功
std::arrayS, 3 a3{1, 2, 3, 4, 5, 6}; // 内层不加括号编译成功这篇文章会介绍这个问题的原理以及正确的解决方式。
聚合初始化
先从std::array的内部实现说起。为了让std::array表现得像原生数组C中的std::array与其他STL容器有很大区别——std::array没有定义任何构造函数而且所有内部数据成员都是public的。这使得std::array成为一个聚合aggregate。
对聚合的定义在每个C版本中有少许的区别这里简单总结下C17中定义一个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;
};templatetypename T, size_t N
struct MyArray {T data[N];
};int main()
{MyArrayint, 3 a1{{1, 2, 3}}; // 两层大括号MyArrayS, 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::arrayS, 3 a3{1, 2, 3, 4, 5, 6}; // 内层不加括号编译成功因为S也是个聚合类型所以这里省略了两层大括号。编译期按照下面的顺序依次填充元素数组0号元素的S::x、数组0号元素的S::y、数组1号元素的S::x、数组1号元素的S::y……
虽然大括号可以省略但是一旦用户显式的写出了大括号那么必须要和这一层的元素个数严格对应。因此下面的写法会报错
std::arrayS, 3 a1{{1, 2}, {3, 4}, {5, 6}}; // 编译失败编译器认为**{1,2}对应std::array的内部数组然后{3,4}对应std::array的下一个内部成员。可是std::array**只有一个数据成员于是报错too many initializers for std::arrayS, 3
需要注意的是大括号省略只对聚合类型有效。如果S有个自定义的构造函数省掉大括号就行不通了
// 聚合
struct S1 {S1() default;int x;int y;
};std::arrayS1, 3 a1{1, 2, 3, 4, 5, 6}; // OK// 聚合
struct S2 {S2() delete;int x;int y;
};std::arrayS2, 3 a2{1, 2, 3, 4, 5, 6}; // OK// 非聚合有用户提供的构造函数
struct S3 {S3() {};int x;int y;
};std::arrayS3, 3 a3{1, 2, 3, 4, 5, 6}; // 编译失败这里可以看出**default**的构造函数与空构造函数的微妙区别。
std::initializer_list的另一个故事
上面讲的所有规则都只对聚合初始化有效。如果我们给MyArray类型加上一个接受std::initializer_list的构造函数情况又不一样了
struct S {int x;int y;
};templatetypename T, size_t N
struct MyArray {
public:MyArray(std::initializer_listT l){std::copy(l.begin(), l.end(), std::begin(data));}T data[N];
};int main()
{MyArrayS, 3 a{{{1, 2}, {3, 4}, {5, 6}}}; // OKMyArrayS, 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_listint 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_listclass DefCtor {int x;
public:DefCtor(){}
};class DeletedDefCtor {int x;
public:DeletedDefCtor() delete;
};class NoDefCtor {int x;
public:NoDefCtor(int){}
};templatetypename T
class X {
public:X() { std::cout Def Ctorn; }X(std::initializer_listT il){std::cout il.size() il.size() n;}
};int main()
{XDefCtor a0({}); // il.size 0XDefCtor b0{{}}; // il.size 1XDeletedDefCtor a2({}); // il.size 0// XDeletedDefCtor b2{{}}; // error! attempt to use deleted constructorXNoDefCtor a1({}); // il.size 0XNoDefCtor 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的例子现在我们可以分析出两种初始化分别是在哪一步成功的
MyArrayS, 3 a{{{1, 2}, {3, 4}, {5, 6}}}; // 在第二步剥掉外层大括号后匹配成功
MyArrayS, 3 b{{1, 2}, {3, 4}, {5, 6}}; // 第一步整个大括号列表匹配成功综合小测试
到这里大括号初始化在各种场景下的规则就都解析完了。不知道读者是否彻底掌握了
不妨来试一试下面的小测试这段代码里有一个仅含一个元素的std::array其元素类型是std::tupletuple只有一个成员是自定义类型SS定义有默认构造函数和接受**std::initializer_list**的构造函数。对于这个类型初始化时允许使用几层大括号呢下面的初始化语句有哪些可以成功分别是为什么
struct S {S() default;S(std::initializer_listint) {}
};int main()
{using MyType std::arraystd::tupleS, 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
