关于c++:大括号之谜C的列表初始化语法解析

30次阅读

共计 5761 个字符，预计需要花费 15 分钟才能阅读完成。

摘要：有敌人在应用 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::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. 没有 private 或protected数据成员；
  2. 没有用户提供的构造函数（然而显式应用 =default 或=delete申明的构造函数除外）；
  3. 没有 virtual、private 或者 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 的构造函数来初始化时，无论初始化列表外层是一层还是两层大括号，都能初始化胜利，而且 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 Ctorn";}
     
  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 的例子，当初咱们能够剖析出两种初始化别离是在哪一步胜利的：

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/Book…
[4] https://scottmeyers.blogspot….

本文分享自华为云社区《大括号之谜——C++ 的列表初始化语法解析》，原文作者：飞得乐。

点击关注，第一工夫理解华为云陈腐技术~

正文完
c++
发表至： c#
2021-03-08
 0
C语言在线运行在线编译
关于c++:CS144-Lab-Assignments-手写TCP-LAB1
关于c++:C-多线程
关于c++:动态规划数组等子集和问题总结