[C++] - 创建对象时 () 和 {} 的区别

C++11以后，对象的初始化可以有多种选择，总的来说，初始值可以通过三种方式给出：(), = 和 {}

int x(0); //initializer is in parentheses int y = 0; //initializer follows "=" int z{ 0 }; //initializer is in braces

使用{}的初始化方式称为uniform initialization，或者又称为braced initialization. Braced initialization适用于任何对象初始化的场景，

// 指定container的初始内容 std::vector<int> v{ 1, 3, 5 }; // v's initial content is 1, 3, 5 // 指定非static成员对象的默认值 class Widget { ... private: int x{ 0 }; // OK int y = 0; // OK int z(0); // error! }; // uncopyable对象的初始化 std::atomic<int> ai1{ 0 }; // OK std::atomic<int> ai2(0); // OK std::atomic<int> ai3 = 0; // error!

Braced initialization的一个新特性是它可以禁止内置类型之间隐式的narrowing conversion。使用 () 和 = 不会检查narrowing conversion。

double x, y, z; int sum1{ x + y + z }; // error! int sum2( x + y + z ); // OK int sum3 = x + y + z; // OK

Braced initialization的另一个特性是它可以避免C++中将对象的默认构造转换成函数声明的情况，

Widget w2(); // 声明一个函数w2, 返回值是Widget Widget w3{}; // 声明一个Widget对象并调用Widget默认构造函数

Braced initialization的缺点：

1.当使用braced initialization初始化auto变量时，类型推断是std::initializer_list而不是你期望的类型，

auto x1 = 27; // type is int, value is 27 auto x2(27); // type is int, value is 27 auto x3 = { 27 }; // type is std::initializer_list<int>, value is {27}

2.如果类的其中一个构造函数的形参是std::initializer_list，那么如果用braced initialization初始化对象，编译器会尽最大可能地调用形参是std::initializer_list的构造函数。

class Widget { public: Widget(int i, bool b); Widget(int i, double d); Widget(std::initializer_list<long double> il); ... }; Widget w1(10, true); //调用第一个构造函数 Widget w2{10, true}; //调用std::initializer_list构造函数，10和true转换成long double Widget w3(10, 5.0); //调用第二个构造函数 Widget w4{10, 5.0}; //调用std::initializer_list构造函数，10和5.0转换成long double

甚至原本是copy构造函数和move构造函数的地方，都会被转换成使用std::initializer_list的构造函数，

class Widget { public: Widget(int i, bool b); Widget(int i, double d); Widget(std::initializer_list<long double> il); operator float() const; ... }; Widget w5(w4); //调用copy构造函数 Widget w6{w4}; //调用std::initializer_list构造函数，w4被转换成float，float被转换成long double Widget w7(std::move(w4)); //使用move构造函数 Widget w8{std::move(w4)}; //使用std::initializer_list函数，w4被转换成float，float被转换成long double

更有甚者，编译器使用std::initializer_list构造函数的决心是如此之大以至于明明不可以转换成std::initializer_list构造函数，它也会去调用，最终导致编译无法通过，

class Widget { public: Widget(int i, bool b); Widget(int i, double d); Widget(std::initializer_list<bool> il); ... }; Widget w{10, 5.0}; // error! 导致narrowing conversion

编译器会忽略前两个构造函数，并调用std::initializer_list构造函数。但这需要将int(10)和double(5.0)转换成bool，这会导致narrowing conversion。然而narrowing conversion在braced initialization中是禁止的，所以调用非法，编译无法通过。

有没有可能既声明了std::initializer_list构造函数，但是编译器还是调用其他普通的构造函数呢？答案是除非braced initialization中参数的类型无法转换成std::initializer_list中的类型。

class Widget { public: Widget(int i, bool b); Widget(int i, double d); Widget(std::initializer_list<std::string> il); ... }; //没办法将 int 和 bool 转换成 std::string Widget w1{10， true}; //调用第一个构造函数 Widget w2{10, 5.0}; //调用第二个构造函数

如果你使用一个空的{}来构造一个既支持默认构造函数又支持std::initializer_list构造函数的类对象，那么最终调用的是哪一个呢？答案是调用默认构造函数，因为空的{}意味着没有参数，并不是一个空的std::initializer_list，

class Widget { public: Widget(); Widget(std::initializer_list<int> il); ... }; Widget w1; //调用默认构造函数 Widget w2{}; //调用默认构造函数 Widget w3(); //声明一个函数！

如果想用空的{}调用std::initializer_list构造函数，可以将空的{}放进()或{}里，

Widget w4({}); // 调用std::initializer_list构造函数，赋值empty list Widget w5{{}}; // 同上

 

翻译整理自：《Effective Modern C++》Chapter3 Moving to Modern C++