Effective C++ 条款20、21

条款20 宁以pass-by-reference-to-const替换pass-by-value

此条款本应就很熟悉，值得记住作者给予的两条忠告：

i、尽量以pass-by-reference-to-const替换pass-by-value。前者通常比较高效，并可避免切割问题（也就是多态的实际运用）。

ii、上述条款并不适用于内置类型，以及STL的迭代器和函数对象。对它们而言，pass-by-value往往比较适当。

以下举例验证上述条款：

class Person {
public:
	Person();
	virtual ~Person();
private:
	string name;
	string address;
};
class Student :public Person {
public:
	Student();
	~Student();
private:
	string schoolName;
	string schoolAddress;
};

//考虑以下调用函数的运用
bool validateStudent(Student s);//函数以by value方式接受学生
Student plato;
bool platoIsOk = validateStudent(plato);

        针对上述函数调用，所传参数只是实参的一个副本，这个时候Student的一个copy构造函数会被调用，加上一次Student析构函数调用，由于Student对象内还有两个string对象，而Student继承自Person对象中又有两个string对象，于是又要承担四次string构造和四次string析构。总共六次构造函数和六次析构函数。

        但如采用pass-by-reference to const可以回避所有那些构造和析构动作，Perfect！

bool validateStudent(const Student& s);//以pass by reference，const是必要的，可以取消调用者修改传递实参的疑虑

以下是避免分割的情况：

class Window {
public:
	string name()const;//返回窗口名称
	virtual void display()const;//显示窗口和其内容
};
class WindowWithScrollBars :public Window {
public:
	virtual void display() const;
};

//以下函数打印窗口名称，然后显示该窗口，错误示范：
void printNameAndDisplay(Window w) {//不正确！参数可能被切割
	cout << w.name;
	w.display();
}

WindowWithScrollBars wwsb;
printNameAndDisplay(wwsb);//无法进行动态绑定，实现不了多态，内部成员被切割的只剩下Window内成员。

        针对上述切割的情况，主要是因为pass by value时会进得copy构造，结果只是传进了一个Window的对象。（此处回顾一下实现多态两要点：1、虚函数的调用；2、父类对象以引用或者指针形式指向子类对象）  正确的写法如下：

void printNameAndDisplay(Window& w) {//正确，多态的实际运用
	cout << w.name;
	w.display();
}

条款21 必须返回对象时，别妄想返回其reference

所谓的reference只是个名称，代表某个既有对象。任何时候看到一个reference声明式，都应该立刻问自己，它的另一个名称是什么？

函数创建新对象的途径有二：在stack空间或在heapp空间创建。

如下定义在stack空间创建一个local变量（会有被销毁的危险）：

class Rational {
public:
	Rational(int numerator = 0, int denominator = 1);
private:
	int n, d;
	friend const Rational operator*(const Rational& lhs, const Rational& rhs);
};

const Rational& operator*(const Rational& lhs, const Rational& rhs) {
	Rational result(lhs.n*rhs.n, lhs.d*rhs.d);//灾难，因为函数一旦结束，此变量就被释放，结果返回的引用就没有地方指向。太灾难了！
	return result;
}

如下定义在heap空间分配一个动态内存（会造成内存泄漏）：

const Rational& operator*(const Rational& lhs, const Rational& rhs) {
	Rational * result = new Rational(lhs.n*rhs.n, lhs.d*rhs.d);//更是灾难，此处将会出一个构造函数的代价，但没有对new的内存进释放而负责的人哈
	return *result;
}

如下采用static定义local变量（ 出现线程安全问题，以及深层次问题，见下分析）：

const Rational& operator*(const Rational& lhs, const Rational& rhs) {
	static Rational result;//垃圾，首先会产生多线程安全问题，其次最严重的问题来了，见下面分析
	return result;
}
bool operator==(const Rational& lhs, const Rational& rhs);
Rational a, b, c, d;
if((a*b)==(c*d)){}//此处将永远为真，由于返回的是reference，所以调用端看到的永远是static Rational对象的“现象”

正确的写法就是返回value即可，而不是reference进行画蛇添足。（相应代码已在给出class Rational类处）

以上内容均来自Scott Meyers大师所著Effective C++ version3，如有错误地方，欢迎指正！相互学习，促进！！