C++优化--按值返回和返回值优化

C++和C语言相比，最为人诟病的就是其性能问题，通常一条C语言经编译器解释后，可以固定转换成5—10条汇编语言，但是一条C++语言，就没有这么幸运了，可能会是3条汇编语言，也可能是300条。C++影响性能的原因很多，其中一个就是临时对象的创建和销毁。这里我简述一种减少创建临时对象的方法--返回值优化问题

很多时候，函数需要按值返回，这其中就会不可避免地涉及到临时对象的创建和销毁。假设定义如下的Complex类：

class Complex
{
friend Complex operator +(const Complex&,const Complex&);
public:
Complex(double r=0, double i=0):real(r),imag(i)
{
cout<<"I'm in constructor"<<endl;
}
Complex(const Complex& c):real(c.real),imag(c.imag)
{
cout<<"I'm in copy constructor"<<endl;
}
Complex& operator =(const Complex& c)
{
real=c.real;
imag=c.imag;
cout<<"I'm in assignment"<<endl;
return *this;
}

void print()
{
cout<<real<<"+"<<imag<<"i"<<endl;
}

~Complex()
{
cout<<"I'm in destructor"<<endl;
}

private:
double real;
double imag;

};

Complex operator +(const Complex& a,const Complex& b)
{
/*Complex retVal;
retVal.real=a.real+b.real;
retVal.imag=a.imag+b.imag;
return retVal;*/
cout<<"calling plus"<<endl;
// return Complex(a.real+b.real,a.imag+b.imag);
Complex retVal(a.real+b.real,a.imag+b.imag);
return retVal;
}

其中的友元函数operator + 是一个按值返回的函数。编译器会将这个函数解释成如下：

void Complex_Add(const Complex& __result,
const Complex& c1,
const Complex& c2)
{
......
}

定义一下语句：Complex a(1,1),b(2,2)，c;

c=a+b;

a和b相加的结果赋值给对象c的过程，可以被转化为：

Complex __tempResult;

Complex_Add(__tempResult, a,b);

c=__tempResult;

可以看出，在上述的一个简单的操作中，编译器会隐蔽地产生一个临时对象__tempResult。这是产生的第一个临时对象，先记下，但是这可能并不是唯一的一个。比如当operator +如下实现时

Complex operator +(const Complex& a,const Complex& b)
{
Complex retVal;
retVal.real=a.real+b.real;
retVal.imag=a.imag+b.imag;
return retVal;
}

在operator +函数内部又会产生一个临时对象retVal，综合一下，编译器在遇到如上的函数定义及调用时会产生如下解释：

void Complex_Add(const Complex& __tempResult,
const Complex& c1,
const Complex& c2)
{

Complex retVal;

retVal.Complex::Complex();

retVal.real=a.real+b.real;

retVal.imag=a.imag+b.imag;

__tempResult.Complex::Complex(retVal);

retVal.Complex::~Complex();

return;

}

所以

Complex a(1,1),b(2,2)，c;

c=a+b;的运行结果是：

I'm in constructor

I'm in constructor

I'm in constructor

I'm in constructor

I'm in copy constructor

I'm in destructor

I'm in assignment

I'm in destructor

I'm in destructor

I'm in destructor

I'm in destructor

下面对程序进行优化，可以通过消除上述过程中产生的两个临时对象来减少对象的创建和析构

首先可以对operator +函数内部的retVal临时对象进行优化，使得直接用__tempResult取代retVal

void Complex_Add(const Complex& __tempResult,
const Complex& c1,
const Complex& c2)
{

__tempResult.Complex::Complex();

__tempResult.real=a.real+b.real;

__tempResult.imag=a.imag+b.imag;

return;

}

以上是Efficient C++中的解释，但是我认为__tempResult.Complex::Complex()不应该在函数内部调用，不过并不影响调用次数。

以上便是RVO优化，很多编译器都是支持的，为了防止某些编译器不支持，可以显式地将operator +函数如下实现：

Complex operator +(const Complex& a,const Complex& b)
{
return Complex(a.real+b.real,a.imag+b.imag);
}

以上这种形式称为未命名变量，有些编译器拒绝对已命名变量的RVO优化（比如前面的retVal），这样我们就消除了局部的retVal临时变量。

下面再谈谈__tempResult临时变量的产生，以及消除的方法：

Complex a(1,1),b(2,2)，c;

c=a+b;

定义c的时候会调用默认的构造函数进行初始化，因此第一条语句执行完之后，c已经是一个存在的对象，所以第二条语句并没有权利去直接修改c的内容，必须要通过调用赋值操作符（=），因此必须要产生一个临时对象，具体解释语句前面已经介绍过，即__tempResult的产生原因。

但是如果在执行第二条语句的时候c没有旧的内容，即c不是一个已经存在的对象，那么就可以直接调用构造函数，而不需要=操作符，这样也就可以避免了__tempResult 的产生。

所以如下的操作

Complex a(1,1),b(2,2);

Complex c=a+b;

其运行结果为

I'm in constructor

I'm in constructor

I'm in constructor

I'm in destructor

I'm in destructor

I'm in destructor

只调用了三次构造函数和析构函数，和没有优化前相比，性能得到了很大的提升哦