如何就地初始化数组？

Question

如何在不复制或移动构造临时元素的情况下初始化数组？当元素具有明确的deleted 复制或移动构造函数时，只有当元素具有默认 ctor 或具有所有默认参数的 ctor 并且我执行以下操作之一时，我才能初始化数组： (a) 明确声明数组, (b) 直接初始化和零初始化数组，或 (c) 复制初始化和零初始化数组。直接（但非零）初始化和复制（但非零）初始化均无法编译。

struct Foo
{
    Foo(int n = 5) : num(n) {}
    Foo(const Foo&) = delete;
    //Foo(Foo&&) = delete;  // <-- gives same effect
    int num;
};

int main()
{
    // Resultant arrays for 'a1', 'a2', and 'a3' are two
    // 'Foo' elements each with 'num' values of '5':

    Foo a1[2];          // plain declaration
    Foo a2[2] {};       // direct initialization and zero initialization
    Foo a3[2] = {};     // copy initialization and zero initialization
    Foo a4[2] {5, 5};   // direct initialization -> ERROR
    Foo a5[2] = {5, 5}; // copy initialization   -> ERROR
}

1. 这 3 种方式是唯一在不复制/移动临时元素的情况下初始化数组的方式吗？
2. a1、a2 和 a3 是否算作初始化？例如a1 是一个声明，但它的元素获取初始值，尽管是默认值。
3. 其中有错误吗？我用 C++14 标志做了这个 GCC 6.3.0。
4. 为什么复制初始化与零初始化相结合仍然在复制初始化的范畴下工作？
5. 一般来说，所有数组初始化都是用花括号来构造临时元素（除非在没有删除复制或移动构造函数时省略（或者省略不适用于数组？））通过每个元素的复制、移动或复制和移动构造的混合？

Answer 1

代码声明Foo a2[2]; 声明了一个数组。初始化数组的唯一方法是通过列表初始化（即用大括号括起来的零个或多个元素的列表），该行为由标题为 aggregate initialization 的标准部分描述。 （术语聚合是指数组，以及满足特定条件的类）。

在聚合初始化中，= 的存在没有任何区别。它的基本定义在C++14 [dcl.init.aggr]/2：

当聚合由初始化列表初始化时，如 8.5.4 中所指定，初始化列表的元素被视为聚合成员的初始化，按递增的下标或成员顺序。每个成员都是从相应的初始化子句复制初始化的。

另外，/7:

如果列表中的初始化子句少于聚合中的成员，则每个未显式初始化的成员都应从其大括号或相等初始化器中初始化，或者，如果没有大括号或相等- 初始化器，来自一个空的初始化器列表 (8.5.4)。

您可以从这里看到复制初始化总是用于每个提供的初始化程序。因此，当初始化程序是表达式时，该类必须存在可访问的复制/移动构造函数。

但是（正如 Anty 所建议的）您可以将初始化程序设置为另一个列表。使用列表进行复制初始化称为复制列表初始化：

Foo a6[2] = {{6}, {6}};

当单个Foo 被列表初始化时，它不是聚合初始化（因为Foo 不是聚合）。所以规则与上面讨论的不同。非聚合类的复制列表初始化属于列表初始化，在 [dcl.init.list]/3.4 中，它为 Foo 指定列表中的初始化器使用重载解析与构造函数参数匹配。在此阶段将选择Foo(int) 构造函数，这意味着不需要复制构造函数。

---

为了完整起见，我会提到nuclear option：

typename std::aligned_storage< sizeof(Foo), alignof(Foo) >::type buf[2];
::new ((void *)::std::addressof(buf[0])) Foo(5);
::new ((void *)::std::addressof(buf[1])) Foo(5);
Foo *a7 = reinterpret_cast<Foo *>(buf);

// ...
a7[0].~Foo();
a7[1].~Foo();

显然，当您无法通过任何其他方式实现目标时，这是最后的手段。

---

注 1：以上适用于 C++14。在 C++17 中，我相信所谓的“保证复制省略”会将复制初始化更改为实际上不需要复制/移动构造函数。一旦标准发布，我希望更新这个答案。草案中的聚合初始化也有一些摆弄。

Answer 2

在您的情况下，您仍然可以使用这些构造：

Foo a4[2] = {{4},{3}};

或

Foo a5[2] {{4},{3}};

Answer 3

您还可以使用 malloc 创建一个指针，然后在其上使用数组语法（如果类是 POD）。例如：

class A {
public:
      int var1;
      int var2;
      public int add(int firstNum, int secondNum) {
          return firstNum + secondNum;
      }
}
A * p = 0;
while(!p) {
    p = (A*)malloc(sizeof(A) * 2);
}
p[0] = {2, 3};
p[1] = {2, 5};

还有一种方法可以将数组初始化为临时值，但我忘了怎么做。

如果类是 POD（plain old data），您可以直接初始化对象数组。为了使类成为 POD，它必须没有构造函数、析构函数或虚拟方法。类中的所有内容也必须声明为 public 才能成为 POD。基本上，POD 类只是一个 c 风格的结构，其中可以包含方法。

Answer 4

我手头没有 C++ 标准，引用它可能是证明我的话的唯一方法。所以要回答你的每一个问题，我只能说：

1. 不，这还不是全部。我无法为您提供详尽的可能性清单，但我之前肯定使用过以下内容：

xx

 struct Foo
 {
     Foo(int n = 5) : num(n) {}
     Foo(const Foo&) = delete;
     Foo(Foo&&) = delete;
     int num;
 };

int main()
{    
    Foo a1[2];          // plain declaration
    Foo a2[2] {};       // direct initialization
    Foo a3[2] = {};     // also direct initialization
    Foo a4[2] { {5}, {5} };   // also direct initialization
    Foo a5[2] = { {5}, {5} }; // also direct initialization 
}

1. 大括号初始化不是声明和复制，它是单独的语言结构。它很可能只是就地构造元素。我不确定这是否适用的唯一情况是{ Foo(5), Foo(5) } 初始化，因为它明确要求创建临时对象。 { 5, 5} 变体是一样的，因为为了初始化一个数组，你需要一个 Foo 对象的大括号初始化列表。由于您不创建任何内容，因此它将使用临时构造函数来获取{ Foo(5), Foo(5) }。 { { 5 }, { 5 } } 变体可以编译，因为编译器知道它可以使用提供的 { 5 } 初始化程序构造 Foo 对象，因此不需要临时变量 - 尽管我不知道允许这样做的确切标准措辞。

2. 不，我认为这些都不是错误。

3. 我记得 C++ 标准中的一句话，基本上是说编译器在创建新变量时总是可以通过直接初始化来替换赋值初始化。

xx

Foo x( 5 );
Foo x { 5 };
Foo x = { 5 }; // Same as above

5. 正如我在上面已经指出的：不，您可以就地初始化数组，您只需要一个适当的元素初始化程序。 { 5 } 将被解释为“Foo 对象的初始化程序”，而普通的 5 将被理解为“可以转换为临时 Foo 对象的值”。初始化器列表通常必须包含元素的初始化器列表或元素的确切类型的项目。如果给出不同的东西，将创建一个临时的。