RVO--Return Value Optimization

概述

返回值优化（Return Value Optimization，简称RVO）是一种编译器优化机制：

当函数需要返回一个对象的时候，如果自己创建一个临时对象用户返回，那么这个临时对象会消耗一个构造函数（Constructor）的调用、一个复制构造函数的调用（Copy Constructor）以及一个析构函数（Destructor）的调用的代价。而如果稍微做一点优化，就可以将成本降低到一个构造函数的代价,这样就省去了一次拷贝构造函数的调用和依次析构函数的调用。

编译使用原则

在使用GNU/g++编译器时可以使用"-fno-elide-constructors"选项来强制g++总是调用copy构造函数，即使在用临时对象初始化另一个同类型对象的时候。

但是在使用VS架构的编译器的时候, 貌似编译器默认直接使用RVO的, 并没有找到什么选项来关闭返回值优化。。。

具体信息请参照http://msdn.microsoft.com/en-us/library/ms364057(VS.80).aspx

例子

我们都知道三种拷贝构造函数调用的时机

①最明显的就是用一个类对象初始化另外一个对象的时候
②函数的参数是类对象，这个是函数按值传参数的时候，包括指针在内都是对原有的值的拷贝.
③函数返回一个类对象，这是一个对象以值传递的方式从函数返回.

但是这些都只是语义上的分析, 现在的编译器的编译策略, 很多情况下会把这些临时对象的创建都隐藏掉...

[cpp] view plain copy print?

1. #include <iostream>  
2. using namespace std;  
3.   
4.   
5. class Base  
6. {  
7. public :  
8.     Base(int num)  
9.     {  
10.         m_num = num;  
11.     }  
12.     Base(const Base &base)  
13.     {  
14.         cout <<"Copy constructor..." <<endl;  
15.     }  
16.   
17.     /*~Base( ) 
18.     { 
19.         cout <<"Destroy...." <<endl; 
20.     } */  
21. private :  
22.     int m_num;  
23.   
24. };  
25.   
26.   
27.   
28. Base GetBase( )  
29. {  
30.     Base base(10);  
31.     cout <<"返回值是对象类型, 应该调用拷贝构造函数" <<endl;  
32.     return base;  
33. }  
34.   
35. void GetBase(Base base)  
36. {  
37.     cout <<"参数是对象类型, 应该调用拷贝构造函数" <<endl;  
38. }  
39.   
40.   
41. int main( )  
42. {  
43.     Base b1(20);  
44.     cout <<"使用一个类对象去初始化另一个类对象,　应该调用拷贝构造函数" <<endl;  
45.     Base b2 = b1;  
46.     //cout <<"使用一个可以隐式转换为Base类对象的整数值1来初始化, 应该调用拷贝构造函数" <<endl;  
47.     //Base b3 = 1;  
48.     b2 = GetBase( );  
49.     GetBase( );  
50. }  

#include <iostream>
using namespace std;

class Base
{
public :
	Base(int num)
	{
	    m_num = num;
	}
	Base(const Base &base)
	{
		cout <<"Copy constructor..." <<endl;
	}

	/*~Base( )
	{
		cout <<"Destroy...." <<endl;
	} */
private :
    int m_num;

};

Base GetBase( )
{
	Base base(10);
	cout <<"返回值是对象类型, 应该调用拷贝构造函数" <<endl;
	return base;
}

void GetBase(Base base)
{
	cout <<"参数是对象类型, 应该调用拷贝构造函数" <<endl;
}

int main( )
{
	Base b1(20);
	cout <<"使用一个类对象去初始化另一个类对象,　应该调用拷贝构造函数" <<endl;
	Base b2 = b1;
	//cout <<"使用一个可以隐式转换为Base类对象的整数值1来初始化, 应该调用拷贝构造函数" <<endl;
	//Base b3 = 1;
	b2 = GetBase( );
	GetBase( );
}

上面的代码，用GCC4.8.1编译, 如果常规进行编译, 就会出现这样的结果

但是如果加上-fno-elide-constructors选项, 调用结果就成为我们所理解的方式

很明显, 默认的RVO设置, 将后面两种情况下, 临时对象的创建优化掉了。。。

编译器无法进行RVO的几种情况

RVO是一个很有帮助的编译优化策略, 但是它的优化实现是依赖于编译器的，也就是说编译器只能对指定的符合其规则的代码， 进行RVO优化,对于不符合要求的却无能为力了，

下面我们总结一下有哪些情况会阻止编译器进行这种优化。

① 函数使用exeception, 为了保证异常的正确捕获, 编译器不会进行RVO

② 不对命名的函数对象（Different Named Objects）, 这个情况是说，函数有可能有多个分支，最终导致有多个不同位置的return语句。对于此项优化，要求所有return返回的对象的名字都是一致的。如写成下面的情况，就不行：

[cpp] view plain copy print?

1. Base Test( )   
2. {  
3.     if(...)  
4.     {  
5.        return b1;  
6.     }  
7.     else  
8.     {  
9.     return b2;  
10.     }  
11. }  

Base Test( )
{
    if(...)
    {
       return b1;
    }
    else
    {
	return b2;
    }
}

因此 优化的关键，就是最好只在一个地方返回。即函数只有一个出口

③ 嵌入的汇编代码中引用了返回对象。

转载：http://blog.csdn.net/gatieme/article/details/22650353