[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++