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

前一小节已经讨论过，pass by vaule的代价有时候是巨大的，pass by refrence比较方便。那么肯定也有人会立刻想到，函数返回值的时候，能不能也采用这种办法来提高程序的效率呢？
为了能够简单且说明问题，这里选择了对于内置类型返回其reference：

int& func()
{
int i=3;
return i;
}

void doNothing(int i)
{
}

int main()
{
int& k=func();

doNothing(7); //注释此行，看看有何区别

cout <<k <<endl;
return 0;
}

首先，返回局部变量的引用是不对的。因为如果你返回一个引用，引用肯定是一个对象的别名，那么你一定要先反问自己：这个引用所代表的实际值到底是谁呢？想到这里，我们就一目了然了：你返回的引用是局部变量i的别名，但是i在函数结束以后，就被释放了！所以此时的返回的是一个垃圾数字。这个程序奇怪的地方在于，如果把doNothing函数注释掉，那么程序竟然能得出正确的值，这里的奥秘在于如果调用了函数，那么栈的内容有可能发生改变，改变之后，程序就得出合理的错误值了。而当这个函数调用被注释掉以后，由于栈的内容没有改变，所以即使i已经被释放了，但是它并没有被清零，值还是3，我还是可以引用它。类似的例子还有就是返回局部变量的指针：
int* func()
{
int i=3;
int *p = &i;
return p;
}
int main()
{

int *p = func();
doNothing(1);
cout<<*p<<endl;
return 0;
}

也许，有人会想到，那么我让p指针时堆上分配的内存不就行了？
int* func()
{

int *p = new int(3);
return p;
}

但这样会则要求函数的调用者手动释放内存，否则会造成内存泄露。最致命的是，有时这种泄露是无法被释放的！

比如下面这个计算有理数的类：
class Rational
{
public:

Rational(int numerrator = 0, int denominator = 1):n(numerrator),d(denominator){}
double getVal()
{
double result = (double)n / double(d);
return result;
}
friend Rational& operator*(const Rational &lhs,const Rational &rhs);
private:
int n;//分子
int d;//分母
};

Rational& operator*(const Rational &lhs,const Rational &rhs)
{
Rational* result = new Rational(lhs.n*rhs.n,lhs.d*rhs.d);
return *result;
}

如果我这样调用：
Rational t1(1,1);
Rational t2(1,2);
Rational t3(1,5);

Rational t4 = t1*t2*t3;

那么t2*t3所new的指针就没办法释放了！

也许有人自作聪明的想到，让返回的引用指向一个定义域函数内部的static对象：
Rational& operator*(const Rational &lhs,const Rational &rhs)
{
static Rational result;
result = Rational(lhs.n*rhs.n,lhs.d*rhs.d);
return result;
}

假如你又定义了比较操作符：
bool operator==(const Rational &rhs)
{
return n == rhs.n && d == rhs.d;
}

但是如果你很快就会发现：if( (t1 * t2) == (t3 * t4))这样的语句总是为true。

原因在于(t1 * t2)会修改reslt的值，而(t3 * t4)又会修改result的值。总之，你始终是在做result == result 的判断，当然为true了。

总结起来就是：绝不要返回一个指向局部对象的指针或者引用，也不要返回指向分配在堆上的对象，也不要返回全局或者静态对象。返回值还是pass by value比较好。