C++中的返回值优化（RVO）

一、命名返回值优化（NRVO）

详见MSDN-命名返回值优化。是Visual C++2005及之后版本支持的优化。

具体来说，就是一个函数的返回值如果是一个对象。那么，正常的返回语句的执行过程是，把这个对象从当前函数的局部作用域，或者叫当前函数的栈空间，拷贝到返回区，使得调用者可以访问。然后程序从当前函数中返回到上一层，即该函数的调用语句处，通过访问返回区的对象，来执行调用语句所在的一整个语句。

当这个函数中所有的返回语句全部是这一个对象的话，那么，命名返回值优化的作用就是，在这个对象建立的时候，直接在返回区建立。这样就使得函数返回时不需要调用拷贝构造函数了，减少了一个对象的创建与销毁过程。

代码如下：

#include <iostream>
using namespace std;

class A
{
public:
A()
{
member = 1;
cout << "default constructor" << endl;
}
A(const A &right)
{
member = right.member;
cout << "copy constructor" << endl;
}
~A()
{
cout << "destructor" << endl;
}
A& operator = (const A &right)
{
cout << "assigning operator" << endl;
return *this;
}
int member;
};

A MyMethod(int n)
{
A retVal;
retVal.member = n;
return retVal;
}

int main()
{
A valA;
valA = MyMethod(10);
return 0;
}

在VS2010的命令行下，进行未优化的编译： cl /Od example.cpp（cl编译的优化选项附文末）。执行example.exe，得到输出结果如下图



再次编译，进行优化后的编译： cl /O2 example.cpp ，执行example.exe，得到输出结果如下图



注：NRVO在多层嵌套函数下依然有效。

实验代码：

#include <iostream>
using namespace std;

class A
{
public:
A()
{
member = 1;
cout << "default constructor" << endl;
}
A(const A &right)
{
member = right.member;
cout << "copy constructor" << endl;
}
~A()
{
cout << "destructor" << endl;
}
A& operator = (const A &right)
{
cout << "assigning operator" << endl;
return *this;
}
int member;
};

A f()
{
A tmp;
return tmp;
}
A MyMethod(int n)
{
A tmp = f();
return tmp;
}

int main()
{
A valA;
valA = MyMethod(10);
return 0;
}

cl /Od结果：



cl /O2结果：

二、未命名返回值优化

还有一种未命名的返回值优化，是这样做的，在返回语句中直接创建一个临时对象并返回。

实际上，这并不太能算是一种优化，因为在/Od的cl编译下也会进行优化。所以，这里相当于一个高效的编程技巧。

如下代码：

#include <iostream>
using namespace std;

class MyClass
{
public:
MyClass()
{
cout << "default constructor at " << this << endl;
}
MyClass(int a, int b)
{
cout << "normal constructor at " << this << endl;
}
MyClass(const MyClass &right)
{
cout << "copy constructor at " << this << endl;
}
~MyClass()
{
cout << "destructor at " << this << endl;
}
};

MyClass MyMethod1(int a, int b)
{
MyClass tmp1(a, b);
MyClass tmp2(b, a);
if(a > b)
{
return tmp1;
}
else
{
return tmp2;
}
}
MyClass MyMethod2(int a, int b)
{
if(a > b)
{
return MyClass(a, b);
}
else
{
return MyClass(b, a);
}
}

int main()
{
MyClass m;
cout << "m at " << &m << endl;
m = MyMethod1(1, 2);
m = MyMethod2(1, 2);
return 0;
}

在MyMethod1中，经历了创建tmp1与tmp2，并根据条件返回某个tmp的过程，不具备前文所述NRVO的条件(所有返回语句都要返回一个相同对象)，那么会有两个tmp对象被创建，其中一个会被拷贝到返回区，再返回到函数调用语句。

但如果在返回语句中直接构造MyClass临时对象，如MyMethod2中所示，这样就可以直接将临时对象构造在返回区中，节省了两个对象的创建与销毁的过程。

用不带优化的/Od编译后，执行后结果如下：



注：未命名的返回值优化在多层函数嵌套下依然有效。

实验代码与NRVO如出一辙：

#include <iostream>
using namespace std;

class A
{
public:
A()
{
cout << "default constructor" << endl;
}
A(const A &right)
{
cout << "copy constructor" << endl;
}
~A()
{
cout << "destructor" << endl;
}
A& operator = (const A &right)
{
cout << "assigning operator" << endl;
return *this;
}
};

A f()
{
return A();
}
A MyMethod(int n)
{
return f();
}

int main()
{
A valA;
valA = MyMethod(10);
return 0;
}

cl /Od结果如下：

三、隐式构造函数优化

当用赋值语句对一个对象进行赋值时，最一般的情况是先执行赋值号右侧的表达式，再将表达式的结果（一般是编译时产生的临时变量）赋值给对象。

然而，当用赋值语句对一个对象进行初始化时，则该表达式的结果就是该对象。即，不需要产生临时变量，而是直接将表达式的结果建立在该对象的位置上。

不是很好表述，代码如下：

#include <iostream>
using namespace std;

class A
{
public:
A()
{
cout << "default constructor" << endl;
}
A(const A &)
{
cout << "copy constructor" << endl;
}
~A()
{
cout << "destructor" << endl;
}
A& operator = (const A &)
{
cout << "operator =" << endl;
return *this;
}
};

A func()
{
return A();
}

int main()
{
A a = func();// A a(func())效果相同
return 0;
}

运行结果如图所示：



func函数中，return右边的A()直接是在函数返回区建立的。而这个返回区，在主函数中，就变成了a。所以只需要一个构造函数。

个人的理解是这样的：在栈空间中，调用函数时，会在压入实参之前，留下一个函数返回值的类型的大小那么大的空间，作为函数的返回区。而新建立的变量a，其地址恰恰就在返回区的这个地方，这两者是完全重合的。所以，在函数返回后，无需将函数返回值作为拷贝构造函数的参数去初始化a，而是——什么都不用做。因为a所在的区域，就是函数的返回区域。

然而，当多重函数这样返回的时候，结果还是一样的。这里让我有点费解。代码如下：

#include <iostream>
using namespace std;

class A
{
public:
A()
{
cout << "default constructor" << endl;
}
A(const A &)
{
cout << "copy constructor" << endl;
}
~A()
{
cout << "destructor" << endl;
}
private:
A& operator = (const A &)
{
cout << "operator =" << endl;
return *this;
}
};

A func1()
{
return A();
}

A func()
{
return func1();
}

int main()
{
A a(func());
return 0;
}

运行的结果和上面的是一样的，还是只执行了一次默认构造函数。

问题是，如果函数返回值的返回区确实是在实参之前，与调用者的下一个局部变量的地址是重合的话，那么，a和func()返回区的地址是重合的，可以理解。可func1()的返回区不应该是在func的栈空间中吗？怎么又会和main中的a重合呢？

现在只能理解这么多了。可能只有了解了C++的函数调用约定之后才能明白吧！

附：Visual Studio(2010)的cl优化选项：