C++代码优化（2）函数设计与返回值优化

       最近在看《提高C++性能的编程技术》，看到返回值优化这一章的时候顺便温习一下《高质量C++编程指南》相应的章节。

（1）函数设计

        1、参数的书写要完整，不要贪图省事只写参数的类型而省略参数名字。如果函数没有参数，则用void填充。

void SetValue(int width, int height);	// 良好的风格
void SetValue(int, int);		// 不良的风格
float GetValue(void);		// 良好的风格
float GetValue();		// 不良的风格

        2、如果参数是指针，且仅作输入用，则应在类型前加const，以防止该指针在函数体内被意外修改。

void StringCopy(char *strDestination，const char *strSource);

        3、如果输入参数以值传递的方式传递对象，则宜改用“const &”方式来传递，这样可以省去临时对象的构造和析构过程，从而提高效率。但是不是所有参数都如此处理，对于内部类型如int，float等则不需要，因为它们不存在构造函数与析构函数，这么处理不会提高多少效率，但是可以使得程序更加简洁易懂。

        4、如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率。而有些场合只能用“值传递”而不能用“引用传递”，否则会出错。

        例如：

class String
{…
	// 赋值函数
	String & operate=(const String &other);	
        // 相加函数，如果没有friend修饰则只许有一个右侧参数
        friend	String   operate+( const String &s1, const String &s2); 
private:
	char *m_data; 
}

//String的赋值函数operate = 的实现如下：
String & String::operate=(const String &other)
{
	if (this == &other)
		return *this;
	delete m_data;
	m_data = new char[strlen(other.data)+1];
	strcpy(m_data, other.data);
	return *this;	// 返回的是 *this的引用，无需拷贝过程
}

        对于赋值函数，应当用“引用传递”的方式返回String对象。如果用“值传递”的方式，虽然功能仍然正确，但由于return语句要把 *this拷贝到保存返回值的外部存储单元之中，增加了不必要的开销，降低了赋值函数的效率。例如：

  String a,b,c;
  …
  a = b;     // 如果用“值传递”，将产生一次 *this 拷贝
  a = b= c; // 如果用“值传递”，将产生两次 *this 拷贝

        对于相加函数，应当用“值传递”的方式返回String对象。如果改用“引用传递”，那么函数返回值是一个指向局部对象temp的“引用”。由于temp是在栈上申请的变量，函数执行完毕后被销毁，将导致返回的“引用”无效。

//String的相加函数operate + 的实现如下：
String  operate+(const String &s1, const String &s2)  
{
	String temp;
	delete temp.data;	// temp.data是仅含‘\0’的字符串
	temp.data = new char[strlen(s1.data) + strlen(s2.data) +1];
	strcpy(temp.data, s1.data);
	strcat(temp.data, s2.data);
	return temp;
}

        5、返回值的写法。

        如果函数返回值是一个对象，要考虑return语句的效率。例如   

return String(s1 + s2);

        这是临时对象的语法，表示“创建一个临时对象并返回它”。不要以为它与“先创建一个局部对象temp并返回它的结果”是等价的，如

String temp(s1 + s2);
return temp;

        实质不然，上述代码将发生三件事。首先，temp对象被创建，同时完成初始化；然后拷贝构造函数把temp拷贝到保存返回值的外部存储单元中；最后，temp在函数结束时被销毁（调用析构函数）。然而“创建一个临时对象并返回它”的过程是不同的，编译器直接把临时对象创建并初始化在外部存储单元中，省去了拷贝和析构的化费，提高了效率。这个再RVO中会详细讲解。

（2）返回值优化RVO

         任何时候避免了对象的创建和清楚就能得到性能上的收益，有一种通常是由编译器实现的优化，通过对源代码进行转换并消除对象的创建实现的。这种优化叫做RVO（Return Value Optimization）。

        以下是Complex类的加法操作符方法，Complex类实现了复数。

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

        假设c1、c2和c3是Complex类的对象，我们执行c3 = c1 + c2;，编译器用的一种技术是创建一个临时对象_result，作为第三个参数按引用传递传递给Complex::operator+()的。

        以下为未经优化与经过返回值优化后，编译器产生的代码如下伪代码。可发现，优化后的代码避免了retVal对象的构造的析构的开销，如《高质量C++编程指南》所讲，_result是在外部存储单元中的。

//未经优化
void Complex_Add(Complex &_result, Complex &c1, Complex &c2)
{
	Complex retVal;
	retVal.Complex::Complex();
	retVal.real = a.real + b.real;
	retVal.imag = a.imag + b.imag;
	_result.Complex::Complex(retVal);
	retVal.Complex::~Complex();
	return;
}

//经过返回值优化后
void Complex_Add(Complex &_result, Complex &c1, Complex &c2)
{
	_result.Complex::Complex();
	_result.real = a.real + b.real;
	_result.imag = a.imag + b.imag;
	return;
}

        编译器优化要维护原来计算的正确性，对于返回值优化来说，编译器将不对复杂的函数执行RVO。例如， 如果一个函数有多个return语句返回不同名称的对象，那么RVO不会被使用。如果想用RVO，则必须使用相同名称的对象。此外， 必须定义一个复制构造函数以“打开”返回值优化。如果有关类没有定义复制构造函数，那么RVO就会悄悄地关闭。

        RVO的应用取决于编译器实现的判断力。需要参考编译器的文档或通过实验来确实是否及何时使用RVO。例如有些编译器只对返回匿名对象的函数使用RVO，如下所示。

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