如果返回结构体类型变量（named return value optimisation，NRVO） ------ 续

为什么？

《More C++ idioms》: 3. Algebraic Hierarchy
 程序执行的流程与自己想的不一样：  

 Number Number::makeReal(double r){Number tx; return tx}



 main:



       Number t = Number::makeReal(10);



   自己想的应该是：先生成tx（默认构造）; 返回时需要一个临时量temp，并以tx初始化（拷贝构造），而后用temp初始化 t (拷贝构造)；



   实际执行流程是：生成tx（默认构造），tx就是t

理解好C语言，自然就知道原因了，见：http://www.cnblogs.com/openix/p/3178259.html

 

更深入一步：

    如果我们以上面给出的原因链接来 理解：

《C++ Primer 》4_th_CN p_214 的 “4、千万不要返回局部对象的引用”

   也许我们会认为 第4点有问题，因为按照“C语言”理解，返回的Number实际上就是在main函数中创建的number, 但是我们应该明白 第4点是绝对没错的，原因只有一点：

    当返回引用时 一定会构建被调用函数的临时量，该临时量与发起调用中的被初始量一定不同。

 

启示：

   返回引用是否一定高效，而直接返回一个结构体是否就一定低效。答案：NO

 

对比以下三个程序：

其中A最高效；B可以完成同样的功能，但是效率太低，而且造成内存泄漏；C根本就是错的（尽管可以完成同样的功能，但是请记住p_214的第4点）

//A 

default constructor this : 0xbff65e4c

temp this : 0xbff65e4c
deconstructor this : 0xbff65e4c

class Base                                                                      

{                                                                               

    public:                                                                     

        Base(const Base &thiz) : val(thiz.val)                                  

        {                                                                       

            cout << "copy constructor this : " << this << endl;                 

            cout << "thiz : " << &thiz << endl;                                 

        }                                                                       

                                                                                

        static Base makeBase(int v)                                             

        {                                                                       

            Base temp(v);                                                       

            return temp;                                                        

        }                                                                       

                                                                                

    private:                                                                    

        int val;                                                                

        Base(int v) : val(v)                                                    

        {                                                                       

            cout << "default constructor this : " << this << endl;              

        }                                                                       

                                                                                

};                                                                              

                                                                                

int main(void)                                                                  

{                                                                               

    Base temp = Base::makeBase(3);                                              

    cout << "temp this : " << &temp << endl;                                    

    return 0;                                                                   

}

 

//B 效率太低，而且内存泄漏

default constructor this : 0x84f1008

copy constructor this : 0xbfa6386c

thiz : 0x84f1008

temp this : 0xbfa6386c

deconstructor this : 0xbfa6386c  //0x84f1008内存泄漏，即使最后进程终止时未被回收的内存，系统将自动回收，可是我们不应依赖于此行为

class Base                                                                      

{                                                                               

    public:                                                                     

        Base(const Base &thiz) : val(thiz.val)                                  

        {                                                                       

            cout << "copy constructor this : " << this << endl;                 

            cout << "thiz : " << &thiz << endl;                                 

        }                                                                       

                                                                                

        static Base& makeBase(int v)                                            

        {                                                                       

            Base *p = new Base(v);                                              

            return *p;                                                          

        }                                                                       

                                                                                

        ~Base(void)                                                             

        {                                                                       

            cout << "deconstructor this : " << this << endl;                    

        }                                                                       

                                                                                

    private:                                                                    

        int val;                                                                

        Base(int v) : val(v)                                                    

        {                                                                       

            cout << "default constructor this : " << this << endl;              

        }                                                                       

                                                                                

};

 

 

//C完全就是错的

In static member function ‘static Base& Base::makeBase(int)’:

warning: reference to local variable ‘temp’ returned [enabled by default]





default constructor this : 0xbf8594cc deconstructor this : 0xbf8594cc copy constructor this : 0xbf8594fc  //显然错了

thiz : 0xbf8594cc

temp this : 0xbf8594fc

deconstructor this : 0xbf8594fc

class Base                                                                      

{                                                                               

    public:                                                                     

        Base(const Base &thiz) : val(thiz.val)                                  

        {                                                                       

            cout << "copy constructor this : " << this << endl;                 

            cout << "thiz : " << &thiz << endl;                                 

        }                                                                       

                                                                                

        static Base& makeBase(int v)                                            

        {                                                                       

            Base temp(v);                                                       

            return temp;                                                        

        }                                                                       

                                                                                

        ~Base(void)                                                             

        {                                                                       

            cout << "deconstructor this : " << this << endl;                    

        }                                                                       

                                                                                

    private:                                                                    

        int val;                                                                

        Base(int v) : val(v)                                                    

        {                                                                       

            cout << "default constructor this : " << this << endl;              

        }                                                                       

                                                                                

};                                                                              

                                                                                

int main(void)                                                                  

{                                                                               

    Base temp = Base::makeBase(3);                                              

    cout << "temp this : " << &temp << endl;                                    

    return 0;                                                                   

}  

 

 

现在我们知道A的效率最高，那么我们是否应该向A这样设计程序，我认为：尽量不要如此，对于Algebraic Hierarchy程序如此设计确实很好，而且使用起来很方便，但是请注意对于A中的makeBase函数，其中只有一个temp变量，因此很容易将main中的t与该变量对应起来，但是如果makeBase中的Base类型变量一旦多起了，编译器自然可以从容应对，但是我们已经不便于我们分析了（因为我们不知是否需要经过一个编译器插入的临时量，并将其通过拷贝构造函数初始化t）。

我错过了比赛……