C++11中的变量初始化

出处：http://www.cnblogs.com/neooelric/p/5828027.html

变量初始化很简单嘛，有什么难的？

打住，不要骄傲，往下看，你会哭的。

 

请看下面四个问题：

    1: 下面的语句有不同吗？不同在哪里？

        widget w;                   // a

       

        widget w();                 // b

        widget w{};                 // c

       

        widget w(x);                // d

        widget w{x};                // e

       

        widget w = x;               // f

        widget w = {x};             // g

       

        auto w = x;                 // h

        auto w = widget{x};         // i

       

    2: 下面两行语句分别作了什么？

        vector<int> v1(10, 20);     // a

        vector<int> v2{10, 20};     // b

       

    3: 经过第一题与第二题的洗礼，请你告诉我用{}来初始化对象有什么好处？

   

    4: 什么情况下应该用()，什么情况下应该用{}，请辩证撕逼！

   

 

我知道当你看到第一题的时候已经想把<C++ Primer>撕了糊墙了。

但糊墙之前至少死个明白，弄清楚这四个题的（参考）答案是什么。

 

解答如下：

   

    在公布答案之前，首先要明白为什么我要提这四个问题。

    看起来这只是一个关于茴字到底有几种写法的酸臭题，屏幕面前的观众至少有30%的人会认为这TM有什么用？老子天天写带class的C也挣工资，破语言细节挖那么细有什么用？

   

    请剩下的70%的同学，和我一起对上面提到的30%的人竖起中指。 fucking pussy!

   

    上面的四道题，其实有以下考量:

        1: 弄清楚默认初始化，直接初始化，拷贝初始化，列表初始化四种初始化方式的异同

        2: 弄清楚用()初始化与用{}初始化的异同

        3: 上面问题中的代码中，有一行根本不是初始化！

       

    搞清楚这四道题的终极目标是总结出简洁的定律（在第四题的答案中），彻底搞清楚有关初始化的一切。

   

    下面，解答正式开始。

   

    第一题：

        widget w;

            这是标准的默认初始化。

            这条语句声明了一个变量，其名为w，其类型为widget。

            1: 对于大多数情景，该变量被默认构造函数widget::widget()所构造。

            2: 若widget是一个内置类型，则w未被初始化，其值是未定义的

            3: 若widget是一个简陋的类，那么w将被由编译器生成的默认构造函数所构造。

                所谓简陋，是指：widget没有显式声明定义任何构造函数

           

        widget w();

            这是一个屎坑，来自于C++臭名昭著的“历史原因”。在现代C++项目中，应极力避免这种写法。

            直观上看，这好像也是一个初始化语句，声明了一个变量，其名为w，其类型为widget，并显式的调用了widget的无参（默认）构造函数widget::widget()

            但其实并不是。注意看下面的语句

                int func();

            看三遍。

            请告诉我，你觉得这是什么？

            对的，这是一个函数声明，显然

                widget w();

            也是一个函数声明。是的，如果一条语句看起来像是一个函数声明，那么你不能假定编译器不会认为这是一个函数声明。

            事实上，这个屎坑每天都被无数人踩来踩去，注意看下面的代码，这在实际项目中也是非常频繁出现的写法：

                // 注意， gadget和doodad是两个类型名

                widget w( gadget(), doodad() );

            你以为你初始化并构造了w，但事实上，你写的是一个函数声明。。

            不信？敲下面的代码试试：

                #include <iostream>

 

                struct A { int a; };

                struct B { int b; };

 

                class C {

                public:

                    int a;

                    int b;

                public:

                    C(A a, B b) : a(a.a), b(b.b) { }

                };

 

                C c1(A(), B());             // 这被编译器认为是一个函数声明

                C c2{ A(), B() };           // 这被编译器认为是一个全局变量的声明+初始化

 

                int main(void) {

 

                    std::cout << c1.a << c1.b << std::endl;     // 编译错误提示应该在这一行，因为c并不是一个C实例，所以没有.a成员

                    std::cout << c2.a << c2.b << std::endl;

                   

                   

                    system("pause");

                   

                    return 0;

                }

 

            在C++11中，你不应该写出这种有二义性的语句。

           

        widget w{};

            这是一个清晰的，令人愉悦的，没有任何二义性的，初始化语句。

            这就是使用{}来进行初始化所带来的第一个好处：用{}来替代()，变量声明初始化就是声明初始化，函数声明就是函数声明，大家井水不犯河水！

            这条语句：声明了一个变量，其名为w，其类型为widget，该变量使用widget的默认构造函数widget::widget()构造

           

            有好事者，言道：“非也！非也！如果widget有一个参数为std::initializer_list的构造函数，难道这条语句不会导致编译器调用那个构造函数吗？”

            不，并不会，C++11标准中明确了，当{}内容为空时，将调用默认构造函数。

           

        widget w(x);

        widget w{x};

            这两行是直接初始化，上面我们谈到的都是默认初始化。

            大家有没有想过，为什么叫“直接”初始化呢？

            因为，假定x不是一个类型名，那么上面两行都是显式的构造函数调用语句，逻辑上效果是widget::widget(x)。

            这里，有两点需要注意

                1: 且当x恰好就是widget的实例时，将调用拷贝构造函数。

                2: 当使用{x}形式时，如果widget定义了一个参数类型为initializer_list的构造函数，那么将调用这个构造函数。

                   如果widget并没有定义这样的构造函数，那么将调用最可能被调用的那个构造函数

                   之所以说最可能，是因为传递参数给函数调用，实参类型并不一定需要精确匹配形参类型，x可能会经过一次类型转换

            那么，这两种写法有什么区别呢？

                区别1:

                    widget w(x); 这种写法还是有歧义的，当x恰好还是一个类型名时，即使在当前作用域有一个变量名也是x，这种写法还会被认为是一个函数声明

                    widget w{x}; 这种写法永远不会被认为是函数声明

                区别2:

                    widget w{x}; 的类型检查与类型转换将更严格，这种写法不允许有精度损失的类型转换，如下所示：

                        int i1( 12.3456 );          // 正确，因为()写法允许精度丢失的类型转换

                        int i2{ 12.3456 };          // 错误，因为{}的写法不允许类型转换时出现精度丢失

                       

        widget w = x;

        widget x = {x};

            这两行都是拷贝初始化，前者是拷贝初始化，后者是拷贝列表初始化

            这两行语句将调用widget的拷贝构造函数或移动构造函数（不知道移动构造函数为何物的，请参阅中文版<C++ Primer>第五版13.6节，470页，英文版531页）

            注意：既然是调用构造函数，那么就可能存在隐式的参数类型转换！

            这里再老生常谈一个注意点，请将下面这句话念三遍：

                这不是赋值！这不是赋值！这不是赋值！

            是的，这两行语句中有=操作符出现，但这真的不是赋值，这是初始化！

            初始化调用的是构造函数，即widget::widget(x)，而赋值调用的是赋值操作符，是widget::operator=(x)

            如果真的不明白为什么里出现了=但不是赋值，请翻书温习基础。

           

            下面是要注意的点：

                1: 如果x恰好是widget的对象，那么就是直接调用拷贝构造函数或者移动构造函数，两行语句效果一致。

                2: 对于widget w = x;而言，如果x并不是widget的对象，！！！理论上！！！，将执行下面的步骤

                    1: 编译器首先用x初始化并构造一个widget类型的临时变量，其构造动作相当于直接初始化，类似于下面的语句

                        widget temp{x};

                       需要注意的是，编译器构造的这个临时变量其实是一个右值变量

                    2: 然后编译器将使用这个右值变量，试图调用widget的移动构造函数，临时右值变量阅后即焚，如果没有移动构造函数，将调用拷贝构造函数。

                   如果存在从x到widget的隐式转换，那么widget w = x的效果等同于widget w(widget(x));

                   注意，这只是理论上的步骤，实际实现上，编译器到底怎么做的，并不确定。在存在类型转换操作符的情况下，可能直接一步到位使用隐式类型转换，只调用一次构造函数。

                   类似于

                        widget temp(widget(x));  // 注意，内层的widget(x)是对类型转换操作符的调用

                   唯一确定的就是：这两行语句都将调用拷贝构造函数或移动构造函数，并且无论如何，请保持拷贝构造函数是存在的，可用的。

                  

            而对于widget x = {x};而言，这叫做拷贝列表初始化。实际上效果和widget w{x};一毛一样，没有任何区别。

           

        auto w = x;

        auto w = widget{x};

            这两行也是拷贝初始化，但更容易理解一点。

            并且对于auto w = widget{x};来讲，无论从x到widget是显式的转换，还是隐式的转换，效果都是相同的。

           

            注意点：

                1: auto w = x;妥妥的调用拷贝构造函数，因为w的类型是推断出来的，所以变成了下面这种

                    type_of_x w = x; ===> type_of_x w(x);

                2: auto w = widget{x};注意{}将搞一个initializer_list出来，所以如果存在参数为initializer_list的构造函数，这个构造函数将被优先调用

                3: 对于auto w = widget{x};来讲，如果x就是widget类型的对象，那么只会调用一次构造函数，优先调用移动构造函数，无移动构造函数将调用拷贝构造函数，效果等同于

                    widget w = widget{x}; ===> widget w{x};

                   而如果x并不是widget类型的对象，那么就势必会发生类型转换，！！！理论上！！！将调用两次构造函数，实际上调用几次我们不得而知，依赖于编译器的具体实现

           

            这是最具C++11的写法，也是最推荐的写法，也就是说，在用C++11的项目中，如果需要用一个对象x，去初始化一个变量w，那么最推荐这种写法

                1: 如果w的类型和x一致，那么请使用

                    auto w = x;

                   类型推断将保证w与x类型一致，带来的后果就是肯定会调用拷贝构造函数

                2: 如果w的类型和x并不一致，那么请使用

                    auto w = type_of_w{x};

                   等号右边保证了无论是显式类型转换还是隐式类型转换，行为都是一致的，无需考虑转换到底是显式的还是隐式的。

                  

       

        关于类型转换的“显式”和“隐式”，请未看过C++11的同学参考中文版<C++ Primer>第五版14.9节，514页，英文版579页

        上文中凡是提到类型转换的部分，对类类型而言，隐式类型转换都指普通的类型转换操作符重载，显式类型转换指带explict关键字的类型转换操作符重载

       

        关于第一题的小总结：

            1: 默认初始化，请使用下面的写法

                type w;

               请抛弃下面的写法

                type w();

            2: 构造的原料与期待的产品类型相同的情况下进行直接初始化，请使用下面的写法

                type w{x};

                auto w = x;

               并至少保证拷贝构造函数可用

            3: 构造的原料与期待的产品类型不同的情况下，请使用下面的写法

                auto w = type_of_w{x};

               保险起见，请保证：

                1: 从type_of_x到type_of_w的（拷贝）构造函数可用

                2: 从type_of_w到type_of_w的拷贝构造函数可用

                3: 从type_of_x到type_of_w的类型转换操作符可用

               

    第二题：

        vector<int> v1(10, 20);  调用的是  vector( size_t n, const int& value );

        vector<int> v2{10, 20};  调用的是  vector( initializer_list<int> values );

        这两个语句都调用了构造函数，都是直接初始化的语法。

        纠结的点在于，vector有多个构造函数，且有两个构造函数符合两个实参的调用，那么，何种情况下调用哪个构造函数呢？

        规则如下：

            1: {/* 至少两个参数 */}语法将搞出一个initializer_list

            2: 形参为initializer_list的构造函数，将优先于普通参数列表的构造函数被调用

        所以：

            vector<int> v1(10, 20);

            assert(v1.size() == 10);

           

            vector<int> v2{10, 20};

            assert(v2.size() == 2);

           

    第三题：

        使用{}是更严格的语法，没有二义性，使用{}的初始化可被称为“具有一致性的初始化语法”

        所谓一致性是指：

            1: 对于所有类型，都可以使用{}语法，语法层面上是统一的。包括简单的聚合结构体，数组，标准库容器，以及普通的类

            2: 没有二义性，说这是一个初始化，这TM就是一个初始化！！！这不是函数声明！

        下面是一致性美学欣赏时间：

            struct mystruct { int x, y, z; };

           

            // C++98中的糊屎语法

            rectangle           w( origin(), extents() );           // 函数声明？初始化？分不清

            complex<double>     c( 2.71828, 3.1415926 );            // 没有毛病

            mystruct            m = {1, 2};                         // 没有毛病

            int                 a[] = {1, 2, 3, 4};                 // 没有毛病

            vector<int>         v;                                  // 有毛病，为了初始化一个简单的向量，竟然要写两行！不能忍！

            for(int i = 0; i < 4; ++i) v.push_back(i);

                                                                    // 总的来看，初始化语法乱七八糟一锅粥

            // C++11里的一致性美感

            rectange            w   = { origin(), extents() };      // 漂亮

            complex<double>     c   = { 2.71828, 3.14159 };         // 美

            mystruct            m   = { 1, 2 };                     // 赏心悦目

            int                 a[] = { 1, 2, 3, 4 };               // 简直享受

            vector<int>         v   = { 1, 2, 3, 4 };               // 啊。。长江。。啊。。黄河！

           

        其实，你或许会说美感都是红粉骷髅，没啥意思，那么你看看下面的泛型代码（看不懂拉倒，我知道很多人并不了解泛型模板，包括我（译者）在内）

            template<typename T, typename ...Args>

            void forwarder( Args&&... args ) {

                // ...

                T local = { std::forward<Args>(args)... };

                // ...

            }

 

            forwarder<int>            ( 42 );                  // ok

            forwarder<rectangle>      ( origin(), extents() ); // ok

            forwarder<complex<double>>( 2.71828, 3.14159 );    // ok

            forwarder<mystruct>       ( 1, 2 );                // 错误

            forwarder<int[]>          ( 1, 2, 3, 4 );          // 错误

            forwarder<vector<int>>    ( 1, 2, 3, 4 );          // 错误

           

        并且，并且，一致性到了成员初始化器都可以使用{}语法

            widget::widget(/* ... */) : mem1{init1}, mem2{init2, init3} { /* ... */ }

           

        并且，在函数调用传递参数、返回值方面，{}也能带给你很多便利

            void draw_rect(rectangle);

           

            draw_rect(rectangle(origin, selection));            // C++98

            draw_rect({origin, selection});                     // C++11

           

            rectangle compute_rect() {

                // **

                if(cpp98)

                    return rectangle(origin, selection);        // C++98

                else

                    return {origin, selection};                 // C++11

            }

           

           

    第四题：

        0: 调用默认构造函数，你应该始终使用{}，例如：

            widget w{};

        1: 要用多个参数搞定的初始化，你应该始终使用{}，例如：

            vector<int> v = {1,2,3,4};

            auto v = vector<int>{1,2,3,4};

           因为{}有上面说过的很多好处，诸如简洁，没有二义性等

        2: 只用一个参数就能搞定的初始化，你可以省略掉{}，转而使用=，例如：

            int i = 42;

            auto x = anything;

           当然，强迫症患者可以从一而终，始终使用{}，例如：

            int i{42};

            auto x{anything};

        3: 只有需要调用特定的构造函数时，才需要在初始化中使用()，如：

            vector<int> v1(10, 20);

            auto v2 = vector<int>(10, 20);

               

        最后一点注意：当你设计一个类时，尽量避免让一个普通构造函数与一个参数带initializer_list的构造函数发生冲突