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

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

是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优化选项：