C++以对象作为返回值时编译器的优化，以及临时变量的析构时机

印象中，函数调用的时候，参数past by value、返回值return by value，总是伴随着对象的复制。

实际上参数传递是这样的，但是返回值有可能不是这样的（虽然大部分都是面临拷贝构造函数的调用），这取决于编译器。

#include<string>  
#include<list>  
#include<iostream>  

using namespace std;  
  
class C  
{  
   public:
   	    C()
   	    {
   	   	    cout<<"C default constructor(),this="<<this<<endl; 
   	    }  
            
        C(const C &c)  
        {  
            cout<<"C const copy constructor(),this="<<this<<",reference="<<&c<<endl;                                  
        }  
          
        C(C &c)  
        {  
            cout<<"C nonconst copy constructor(),this="<<this<<",reference="<<&c<<endl;            
        }  
          
        const C & operator=(const C &c)  
        {  
            cout<<"C assignment(),this="<<this<<endl;  
            return *this;  
        }  
        ~C()  
        {  
            cout<<"C destructor(),this="<<this<<endl;  
        } 
};  
      
      
C test_1(int i)  
{  
	 cout<<"entering test_1"<<endl; 
   C x;  
   C a;           //a会析构
   cout<<"leaving test_1"<<endl; 
   return x;      //return之后栈不清空，x不会析构,即使编译器已经将优化设置成-O0  
  
}  
      
C test_2(int i) 
{  
	 cout<<"entering test_2"<<endl; 
   C x;  
   C a;  
   
   cout<<"leaving test_2"<<endl;
   if(i>0) 
       return x;   
   else  
       return a;    //x和a都会析构，返回的时候，先调用拷贝构造函数，初始化返回值（此处为main里面的z）,  
                    //然后再析构a和x  
} 


C test_3(C t)
{
	return t;        //此处导致t的构造和析构
} 

C test_4(C t)
{
	C x=t;
	return x;        //此处导致t的构造和析构，但是x只会构造不会析构
} 

int main()
{
   cout<<"invoking test_1"<<endl;
   C y=test_1(1); //这种调用不会有拷贝构造函数，y直接为test_1函数栈里面生成的对象，编译器优化的结果
   cout<<"end invoke test_1"<<endl;
   
   cout<<"================华丽分割线================="<<endl;
   
   cout<<"invoking test_2"<<endl;
   C z=test_2(1);  //这种情况会调用拷贝构造函数（nonconst版本），初始化z
   cout<<"end invoke test_2"<<endl; 
   
   cout<<"================华丽分割线================="<<endl;
   
   cout<<"invoking test_3"<<endl;
   C a=test_3(y);  
   cout<<"end invoke test_3"<<endl; 
   
   
   cout<<"================华丽分割线================="<<endl;
   
   cout<<"invoking test_4"<<endl;
   C b=test_4(y);  
   cout<<"end invoke test_4"<<endl;  
   
  cout<<"================华丽分割线================="<<endl;
   
   cout<<"开始测试临时变量何时析构"<<endl;
   test_2(1),                         //(注意结束处是逗号)此处返回的C没有指定任何变量，编译器会生成临时变量                                         
   cout<<"结束测试临时变量何时析构"<<endl;//临时变量会再语句的第一个分号处析构，cout完成之后析构
   
   cout<<"================华丽分割线================="<<endl;
   
   cout<<"开始测试临时变量何时析构"<<endl;
   test_2(1);                         //(注意结束处是分号)此处返回的C没有指定任何变量，编译器会生成临时变量                                         
   cout<<"结束测试临时变量何时析构"<<endl;//临时变量会再语句的第一个分号处析构，cout开始之前析构
   
   cout<<"================华丽分割线================="<<endl;
   cout<<"================下面开始析构栈里面的变量了，啦啦啦================="<<endl;
   cout<<"================析构顺序按照入栈的顺序，后进先出，后构造，先析构==========="<<endl;
   return 0;

}

运行结果：

AlexdeMacBook-Pro:~ alex$ a.out
invoking test_1
entering test_1
C default constructor(),this=0x7fff5929baa8
C default constructor(),this=0x7fff5929b8d8
leaving test_1
C destructor(),this=0x7fff5929b8d8
end invoke test_1
================华丽分割线=================
invoking test_2
entering test_2
C default constructor(),this=0x7fff5929b8d8
C default constructor(),this=0x7fff5929b8d0
leaving test_2
C nonconst copy constructor(),this=0x7fff5929ba98,reference=0x7fff5929b8d8
C destructor(),this=0x7fff5929b8d0
C destructor(),this=0x7fff5929b8d8
end invoke test_2
================华丽分割线=================
invoking test_3
C nonconst copy constructor(),this=0x7fff5929ba88,reference=0x7fff5929baa8
C nonconst copy constructor(),this=0x7fff5929ba90,reference=0x7fff5929ba88
C destructor(),this=0x7fff5929ba88
end invoke test_3
================华丽分割线=================
invoking test_4
C nonconst copy constructor(),this=0x7fff5929ba78,reference=0x7fff5929baa8
C nonconst copy constructor(),this=0x7fff5929ba80,reference=0x7fff5929ba78
C destructor(),this=0x7fff5929ba78
end invoke test_4
================华丽分割线=================
开始测试临时变量何时析构
entering test_2
C default constructor(),this=0x7fff5929b8d8
C default constructor(),this=0x7fff5929b8d0
leaving test_2
C nonconst copy constructor(),this=0x7fff5929ba70,reference=0x7fff5929b8d8
C destructor(),this=0x7fff5929b8d0
C destructor(),this=0x7fff5929b8d8
结束测试临时变量何时析构
C destructor(),this=0x7fff5929ba70
================华丽分割线=================
开始测试临时变量何时析构
entering test_2
C default constructor(),this=0x7fff5929b8d8
C default constructor(),this=0x7fff5929b8d0
leaving test_2
C nonconst copy constructor(),this=0x7fff5929ba68,reference=0x7fff5929b8d8
C destructor(),this=0x7fff5929b8d0
C destructor(),this=0x7fff5929b8d8
C destructor(),this=0x7fff5929ba68
结束测试临时变量何时析构
================华丽分割线=================
================下面开始析构栈里面的变量了，啦啦啦=================
================析构顺序按照入栈的顺序，后进先出，后构造，先析构===========
C destructor(),this=0x7fff5929ba80
C destructor(),this=0x7fff5929ba90
C destructor(),this=0x7fff5929ba98
C destructor(),this=0x7fff5929baa8
AlexdeMacBook-Pro:~ alex$
AlexdeMacBook-Pro:~ alex$

结论：

一：return by value时候编译器的优化

编译器在能够做优化的时候，会尽量帮你做优化，比如test_1，总是将栈里面的x直接给调用者，避免了多一次的析构和构造。即使在关闭编译器优化的时候，它依然给你做了这个动作。但是在test_2里面，返回值是动态的，随着参数变动而变动，编译器是没有办法得知保留哪个的，于是索性都析构了。

在Effective C++ Item 21,page 94, Don't try to return a reference when you must return an object.

作者说：C++和所有编程语言一样，允许编译器实现者施行最优化，用以改善产出码的效率却不改变其可观察的行为。

g++确实对此做了优化，但是动态返回值，编译器却无能为力。你无法要求编译器按照每个分支，生成不同的代码。否则在复杂的程序下，生成的可执行文件大小那将无法估计了

二：临时变了的析构时机

临时变量，总是在执行完生成临时变量的那一行代码之后析构

（是不是比较拗口？）

那就这样说吧：生成临时变量之后，遇到第一个分号，析构函数开始调用