532 
MyClass a1 {a};     // clearer and less error-prone than the other three
MyClass a2 = {a};
MyClass a3 = a;
MyClass a4(a);

为什么？

4

5 回答 5

474

基本上是从 Bjarne Stroustrup 的“The C++ Programming Language 4th Edition”复制和粘贴：

列表初始化不允许缩小 (§iso.8.5.4)。那是：

  • 一个整数不能转换为另一个不能保存其值的整数。例如，允许从 char 到 int，但不允许从 int 到 char。
  • 浮点值不能转换为另一种不能保存其值的浮点类型。例如，允许双精度浮点数，但不允许双精度浮点数。
  • 浮点值不能转换为整数类型。
  • 整数值不能转换为浮点类型。

例子：

void fun(double val, int val2) {

    int x2 = val;    // if val == 7.9, x2 becomes 7 (bad)

    char c2 = val2;  // if val2 == 1025, c2 becomes 1 (bad)

    int x3 {val};    // error: possible truncation (good)

    char c3 {val2};  // error: possible narrowing (good)

    char c4 {24};    // OK: 24 can be represented exactly as a char (good)

    char c5 {264};   // error (assuming 8-bit chars): 264 cannot be 
                     // represented as a char (good)

    int x4 {2.0};    // error: no double to int value conversion (good)

}

= 优于 {}的唯一auto情况是使用关键字来获取由初始化程序确定的类型。

例子：

auto z1 {99};   // z1 is an int
auto z2 = {99}; // z2 is std::initializer_list<int>
auto z3 = 99;   // z3 is an int

结论

除非您有充分的理由不这样做，否则首选 {} 初始化而不是替代方法。

于 2013-08-14T03:56:12.220 回答
161

关于使用列表初始化的优点已经有了很好的答案，但是我个人的经验法则是尽可能不要使用花括号，而是让它依赖于概念含义：

  • 如果我正在创建的对象在概念上包含我在构造函数中传递的值（例如容器、POD 结构、原子、智能指针等），那么我正在使用大括号。
  • 如果构造函数类似于普通的函数调用（它执行一些或多或少复杂的操作，这些操作由参数参数化），那么我使用的是普通的函数调用语法。
  • 对于默认初始化，我总是使用花括号。
    一方面，这样我总是确定对象被初始化，不管它是一个“真实的”类，它有一个无论如何都会被调用的默认构造函数，还是一个内置/POD类型。其次，在大多数情况下，它与第一条规则一致，因为默认初始化对象通常表示“空”对象。

以我的经验，这个规则集可以比默认使用花括号更一致地应用，但是当它们不能被使用或具有与带括号的“正常”函数调用语法不同的含义时，必须明确记住所有异常（调用不同的重载）。

例如，它非常适合标准库类型，例如std::vector：

vector<int> a{10,20};   //Curly braces -> fills the vector with the arguments

vector<int> b(10,20);   //Parentheses -> uses arguments to parametrize some functionality,                          
vector<int> c(it1,it2); //like filling the vector with 10 integers or copying a range.

vector<int> d{};      //empty braces -> default constructs vector, which is equivalent
                      //to a vector that is filled with zero elements
于 2016-05-14T15:24:43.633 回答
112

使用大括号初始化的initializer_list<>原因有很多，但您应该知道构造函数优于其他构造函数，默认构造函数是例外。这会导致构造函数和模板出现问题，其中类型T构造函数可以是初始化列表或普通的旧 ctor。

struct Foo {
    Foo() {}

    Foo(std::initializer_list<Foo>) {
        std::cout << "initializer list" << std::endl;
    }

    Foo(const Foo&) {
        std::cout << "copy ctor" << std::endl;
    }
};

int main() {
    Foo a;
    Foo b(a); // copy ctor
    Foo c{a}; // copy ctor (init. list element) + initializer list!!!
}

假设您没有遇到此类类，则没有理由不使用初始化器列表。

于 2013-08-14T06:22:13.203 回答
5

只要您不使用 -Wno-narrowing 进行构建，就像 Google 在 Chromium 中所做的那样，它只会更安全。如果你这样做了，那就不太安全了。如果没有这个标志，唯一的不安全情况将由 C++20 修复。

注意：A）大括号更安全，因为它们不允许变窄。B）花括号不太安全，因为它们可以绕过私有或删除的构造函数，并隐式调用显式标记的构造函数。

这两个组合意味着如果里面是原始常量，它们会更安全，但如果它们是对象，则安全性会降低（尽管在 C++20 中已修复）

于 2019-10-03T13:24:42.493 回答
2

更新 (2022-02-11)：请注意，与最初发布的主题（下）相比，有更多关于该主题的最新意见反对 {} 初始化程序的偏好，例如 Arthur Dwyer 在他关于The Knightmare的博客文章中C++ 中的初始化。

原答案：

阅读Herb Sutter 的（更新的）GotW #1。这详细解释了这些之间的区别，以及更多选项，以及与区分不同选项的行为相关的几个陷阱。

第 4 节的要点/复制：

什么时候应该使用 ( ) 与 { } 语法来初始化对象？为什么？这是简单的指南：

指导原则：优先使用带{}的初始化，如vector v = { 1, 2, 3, 4 }；或 auto v = vector{ 1, 2, 3, 4 };，因为它更一致、更正确，并且完全避免了了解旧式陷阱。在您希望只看到 = 符号的单参数情况下，例如 int i = 42; 和自动 x = 任何东西；省略括号很好。…</p>

这涵盖了绝大多数情况。只有一个主要的例外：

… 在极少数情况下，例如向量 v(10,20)；或 auto v = vector(10,20);，使用 ( ) 初始化显式调用构造函数，否则该构造函数会被 initializer_list 构造函数隐藏。

然而，这通常应该是“罕见的”的原因是因为默认和复制构造已经很特殊并且可以与 { } 一起工作，并且好的类设计现在大多避免用户定义构造函数的求助于（）情况，因为这个最终设计指南：

指南：当你设计一个类时，避免提供一个用 initializer_list 构造函数重载的构造函数，这样用户就不需要使用 () 来访问这样一个隐藏的构造函数。

另请参阅有关该主题的核心指南：ES.23: Prefer the {}-initializer syntax。

于 2021-10-06T14:40:16.193 回答