15

考虑以下代码：

#include <array>

struct A
{
    int a;
    int b;
};

static std::array<A, 4> x1 =
{
        { 1, 2 },
        { 3, 4 },
        { 5, 6 },
        { 7, 8 }
};

static std::array<A, 4> x2 =
{
    {
        { 1, 2 },
        { 3, 4 },
        { 5, 6 },
        { 7, 8 }
    }
};

static std::array<A, 4> x3 =
{
       A{ 1, 2 },
       A{ 3, 4 },
       A{ 5, 6 },
       A{ 7, 8 }
};

static std::array<A, 4> x4 =
{
       A{ 1, 2 },
        { 3, 4 },
        { 5, 6 },
        { 7, 8 }
};

使用 gcc 编译：

$ gcc -c --std=c++11 array.cpp
array.cpp:15:1: error: too many initializers for ‘std::array<A, 4ul>’
 };
 ^
$

NB1：注释掉第一个初始化语句，代码编译没有错误。
NB2：将所有初始化转换为构造函数调用会产生相同的结果。
NB3：MSVC2015 的行为相同。

我可以看到为什么第一次初始化无法编译，为什么第二次和第三次都可以。（例如参见C++11：正确的 std::array 初始化？。）

我的问题是：为什么最终的初始化会编译？

4

1 回答 1

28

{短版：以停止大括号省略开头的初始化子句。在第一个使用 的示例中就是这种情况{1,2}，但在使用 的第三个或第四个示例中则不然A{1,2}。大括号省略使用接下来的 N 个初始化子句（其中 N 取决于要初始化的聚合），这就是为什么只有 N 的第一个初始化子句不能以 . 开头{。

在我所知道的 C++ 标准库的所有实现中，std::array是一个包含 C 样式数组的结构。也就是说，您有一个包含sub-aggregate 的聚合，就像

template<typename T, std::size_t N>
struct array
{
    T __arr[N]; // don't access this directly!
};

因此，当std::array从一个花括号初始化列表初始化 a 时，您必须初始化包含的数组的成员。因此，在这些实现中，显式形式为：

std::array<A, 4> x = {{ {1,2}, {3,4}, {5,6}, {7,8} }};

最外面的一组大括号指的是std::array结构；第二组大括号指的是嵌套的 C 样式数组。

C++ 允许在初始化嵌套聚合时在聚合初始化中省略某些大括号。例如：

struct outer {
    struct inner {
        int i;
    };
    inner x;
};

outer e = { { 42 } };  // explicit braces
outer o = {   42   };  // with brace-elision

规则如下（使用 N4527 后的草案，即 C++14 后，但 C++11 包含与此相关的缺陷）：

可以在初始化列表中省略大括号，如下所示。如果 初始化器列表以左大括号开头，则后续的初始化器子句的逗号分隔列表初始化子聚合的成员；初始化子句比成员多是错误的 。但是，如果子聚合的初始化器列表 不以左大括号开头，则仅从列表中获取足够的初始化器子句来初始化子聚合的成员；任何剩余的初始化子句都被留下来初始化当前子聚合是其成员的聚合的下一个成员。

将此应用于第一个std::array示例：

static std::array<A, 4> x1 =
{
        { 1, 2 },
        { 3, 4 },
        { 5, 6 },
        { 7, 8 }
};

这解释如下：

static std::array<A, 4> x1 =
{        // x1 {
  {      //   __arr {
    1,   //     __arr[0]
    2    //     __arr[1]
         //     __arr[2] = {}
         //     __arr[3] = {}
  }      //   }

  {3,4}, //   ??
  {5,6}, //   ??
  ...
};       // }

第一个{被视为std::array结构的初始值设定项。然后将初始化子句 {1,2}, {3,4}等作为 的子聚合的初始化器std::array。请注意，std::array只有一个 subaggregate __arr。由于第一个初始化子句 {1,2}以 a 开头{，因此不会发生大括号A __arr[4]省略异常，并且编译器会尝试使用 初始化嵌套数组{1,2}。其余的初始化子句 {3,4}, {5,6}等不涉及任何子聚合，std::array因此是非法的。

在第三个和第四个示例中，子聚合的第一个初始化子句std::array 不以 a 开头{，因此应用了大括号省略异常：

static std::array<A, 4> x4 =
{
       A{ 1, 2 }, // does not begin with {
        { 3, 4 },
        { 5, 6 },
        { 7, 8 }
};

所以解释如下：

static std::array<A, 4> x4 =
  {             // x4 {
                //   __arr {       -- brace elided
    A{ 1, 2 },  //     __arr[0]
    { 3, 4 },   //     __arr[1]
    { 5, 6 },   //     __arr[2]
    { 7, 8 }    //     __arr[3]
                //   }             -- brace elided
  };            // }

因此，A{1,2}导致所有四个初始化子句都被消耗以初始化嵌套的 C 样式数组。如果添加另一个初始化程序：

static std::array<A, 4> x4 =
{
       A{ 1, 2 }, // does not begin with {
        { 3, 4 },
        { 5, 6 },
        { 7, 8 },
       X
};

然后这X将用于初始化 的下一个子聚合std::array。例如

struct outer {
    struct inner {
        int a;
        int b;
    };

    inner i;
    int c;
};

outer o =
  {        // o {
           //   i {
    1,     //     a
    2,     //     b
           //   }
    3      //   c
  };       // }

Brace-elision 使用接下来的 N 个初始化子句，其中 N 是通过初始化（子）聚合所需的初始化数来定义的。因此，只有这 N 个初始化子句中的第一个子句是否以 a 开头才重要{。

更类似于 OP：

struct inner {
    int a;
    int b;
};

struct outer {
    struct middle {
        inner i;
    };

    middle m;
    int c;
};

outer o =
  {              // o {
                 //   m {
    inner{1,2},  //     i
                 //   }
    3            //   c
  };             // }

请注意，大括号省略是递归应用的；我们甚至可以写出令人困惑的

outer o =
  {        // o {
           //   m {
           //     i {
    1,     //       a
    2,     //       b
           //     }
           //   }
    3      //   c
  };       // }

我们省略了 和 的大o.m括号o.m.i。前两个初始化子句用于初始化o.m.i，其余的初始化子句o.c。一旦我们在 周围插入一对大括号1,2，它就被解释为对应于 的一对大括号o.m：

outer o =
  {        // o {
    {      //   m {
           //     i {
      1,   //       a
      2,   //       b
           //     }
    }      //   }
    3      //   c
  };       // }

在这里，初始化器o.m确实以 a 开头{，因此大括号省略不适用。o.m.iis的初始化1器不以 a 开头{，因此应用了大括号省略，并且消耗o.m.i了两个初始化器1and 。2

于 2015-07-16T09:48:12.357 回答