何时使用支架封闭的初始化器？

Question

在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};
}

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

在模板代码方面,更改语法可能会产生不同的含义,因此以正确的方式进行是至关重要的.

我想知道是否存在一个应该选择语法的通用指南.

Answer 1

我认为以下内容可能是一个很好的指导方针:

• 如果要初始化的(单个)值是对象的确切值,请使用copy(=)初始化(因为如果出现错误,您将永远不会意外地调用显式构造函数,这通常会解释提供的值不同).在没有复制初始化的地方,请查看大括号初始化是否具有正确的语义,如果是,请使用; 否则使用括号初始化(如果这也不可用,那么你运气不好).

• 如果要初始化的值是要存储在对象中的值列表(如矢量/数组的元素,或复数的实/虚部分),请使用花括号初始化(如果可用).

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

Answer 2

我很确定永远不会有通用指南.我的方法是始终使用花括号记住它

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

所以圆形和花括号不可互换.但是知道它们的不同之处允许我在大多数情况下使用大括号初始化(在某些情况下我当前不能编译器错误).

Answer 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.