何时使用括号括起来的初始化程序？

在C ++ 11中，我们具有用于初始化类的新语法，这为我们提供了许多初始化变量的可能性。

{ // Example 1
  int b(1);
  int a{1};
  int c = 1;
  int d = {1};
}
{ // Example 2
  std::complex<double> b(3,4);
  std::complex<double> a{3,4};
  std::complex<double> c = {3,4};
  auto d = std::complex<double>(3,4);
  auto e = std::complex<double>{3,4};
}
{ // Example 3
  std::string a(3,'x');
  std::string b{3,'x'}; // oops
}
{ // Example 4
  std::function<int(int,int)> a(std::plus<int>());
  std::function<int(int,int)> b{std::plus<int>()};
}
{ // Example 5
  std::unique_ptr<int> a(new int(5));
  std::unique_ptr<int> b{new int(5)};
}
{ // Example 6
  std::locale::global(std::locale("")); // copied from 22.4.8.3
  std::locale::global(std::locale{""});
}
{ // Example 7
  std::default_random_engine a {}; // Stroustrup's FAQ
  std::default_random_engine b;
}
{ // Example 8
  duration<long> a = 5; // Stroustrup's FAQ too
  duration<long> b(5);
  duration<long> c {5};
}

对于我声明的每个变量，我都必须考虑应该使用哪种初始化语法，这会降低我的编码速度。我确定这不是引入大括号的意图。

对于模板代码，更改语法可能导致不同的含义，因此正确的方法至关重要。

我想知道是否有一个通用的指南应该选择哪种语法。

我认为以下可能是一个很好的指南：

• 如果您要初始化的（单个）值是对象的确切值，请使用copy（=）初始化（因为如果出现错误，您将永远不会意外地调用显式构造函数，该构造函数通常会解释提供的值不同地）。在复制初始化不可用的地方，请检查花括号初始化是否具有正确的语义，如果可以，请使用正确的语义。否则，请使用括号初始化（如果该方法也不可用，则无论如何您还是不走运）。

• 如果您要初始化的值是要存储在对象中的值的列表（如向量/数组的元素或复数的实/虚部），请使用花括号初始化（如果有）。

• 如果要初始化的值不是要存储的值，而是描述对象的预期值/状态，请使用括号。示例是的大小参数vector或的文件名参数fstream。

我敢肯定，永远不会有通用的准则。我的方法是使用大括号记住

1. 初始化程序列表构造函数优先于其他构造函数
2. 所有标准库容器和std :: basic_string具有初始化程序列表构造函数。
3. 大括号初始化不允许缩小转换范围。

因此，圆括号和花括号不可互换。但是，知道它们的不同之处，使我可以在大多数情况下使用圆括号大括号初始化（在某些情况下，我目前不是编译器错误）。

在通用代码（即模板）之外，您可以（而且我也可以）在任何地方使用花括号。优点之一是它可以在任何地方使用，例如即使是在类内初始化：

struct foo {
    // Ok
    std::string a = { "foo" };

    // Also ok
    std::string b { "bar" };

    // Not possible
    std::string c("qux");

    // For completeness this is possible
    std::string d = "baz";
};

或对于函数参数：

void foo(std::pair<int, double*>);
foo({ 42, nullptr });
// Not possible with parentheses without spelling out the type:
foo(std::pair<int, double*>(42, nullptr));

对于变量，我在T t = { init };或T t { init };样式之间不太关注，我发现两者之间的差别很小，最坏的情况是只会产生有用的有关滥用explicit构造函数的编译器消息。

对于std::initializer_list显然可以接受的类型，有时std::initializer_list需要非构造函数（经典示例为std::vector<int> twenty_answers(20, 42);）。最好不要使用括号。

对于通用代码（即在模板中），最后一段应该提出一些警告。考虑以下：

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{ return std::unique_ptr<T> { new T { std::forward<Args>(args)... } }; }

然后auto p = make_unique<std::vector<T>>(20, T {});，如果产生大小为2的向量T是例如int，或大小20的矢量，如果T是std::string。一个非常有说服力的迹象表明，这里发生了非常错误的事情，就是没有任何特征可以在这里拯救您（例如，使用SFINAE）：std::is_constructible就直接初始化而言，而我们正在使用括号初始化，它可以直接仅当没有构造函数进行std::initializer_list干扰时才进行初始化。同样std::is_convertible没有帮助。

我研究了是否可以手动滚动一个可以解决该问题的特征，但我对此并不感到过分乐观。无论如何，我认为我们不会错过太多东西，我认为make_unique<T>(foo, bar)构成等效的事实T(foo, bar)非常直观。特别是考虑到这make_unique<T>({ foo, bar })是完全不同的，并且仅当foo和bar具有相同的类型时才有意义。

因此，对于通用代码，我仅使用大括号进行值初始化（例如T t {};或T t = {};），这非常方便，并且我认为优于C ++ 03方式T t = T();。否则，它要么是直接初始化语法（即T t(a0, a1, a2);），要么是默认构造（T t; stream >> t;这是我认为的唯一使用情况）。

但是，这并不意味着所有括号都不好，请考虑带有修复程序的先前示例：

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{ return std::unique_ptr<T> { new T(std::forward<Args>(args)...) }; }

std::unique_ptr<T>即使实际类型取决于模板参数，它仍然使用花括号来构造T。