C++返回值是类名和返回值是引用的区别及说明
返回值是类名和返回值是引用的区别
返回非引用类型
函数的返回值用于初始化在调用函数时创建的临时对象(temporary object)，如果返回类型不是引用，在调用函数的地方会将函数返回值复制给临时对象。
在求解表达式的时候，如果需要一个地方存储其运算结果，编译器会创建一个没命名的对象，这就是临时对象。C++程序员通常用temporary这个术语来代替temporary object。
用函数返回值初始化临时对象与用实参初始化形参的方法是一样的。
当函数返回非引用类型时，其返回值既可以是局部对象，也可以是求解表达式的结果。
返回引用类型
当函数返回引用类型时，没有复制返回值，相反，返回的是对象本身。
千万不要返回局部对象的引用！千万不要返回指向局部对象的指针！
当函数执行完毕时，将释放分配给局部对象的存储空间。此时对局部对象的引用就会指向不确定的内存！返回指向局部对象的指针也是一样的，当函数结束时，局部对象被释放，返回的指针就变成了不再存在的对象的悬垂指针。
返回引用时，要求在函数的参数中，包含有以引用方式或指针方式存在的，需要被返回的参数。
如果返回对象，最后多执行一次拷贝构造函数，如果返回引用，直接返回现存对象
#include <iostream>
using namespace std;
class Timer
{
public:
Timer();
Timer(int, int, int);
friend Timer &operator+(Timer&, Timer&);
friend Timer operator-(Timer&, Timer&);
friend ostream& operator<<(ostream &out, Timer &t);
friend istream& operator>>(istream &in, Timer &t);
private:
int hour, minute, second;
};
Timer::Timer()
{
hour = 0;
minute = 0;
second = 0;
}
Timer::Timer(int hour, int minute, int second)
{
this->hour = hour;
this->minute = minute;
this->second = second;
}
Timer & operator+(Timer& a, Timer &b)
{
a.second = a.second + b.second;
a.minute = a.minute + b.minute;
a.hour = a.hour + b.hour;
if (a.second >= 60)
{
a.second = a.second - 60;
a.minute++;
}
if (a.minute >= 60)
{
a.minute = a.minute - 60;
a.hour++;
}
return a;
}
Timer operator-(Timer &a, Timer &b)
{
Timer c;
c.hour = a.hour - b.hour;
c.minute = a.minute - b.minute;
c.second = a.second - b.second;
if (c.second < 0)
{
c.second += 60;
c.minute--;
}
if (c.minute < 0)
{
c.minute += 60;
c.hour--;
}
return c;
}
ostream& operator<<(ostream &out, Timer &t)
{
out << t.hour << ":" << t.minute << ":" << t.second << endl;
return out;
}
istream& operator>>(istream&in, Timer &t)
{
cout << "Input hours and minutes." << endl;
in >> t.hour >> t.minute >> t.second;
return in;
}
int main()
{
Timer t1, t2, t3, t4;
cin >> t1 >> t2;
cout << "t1=" << t1;
cout << "t2=" << t2;
t3 = t1 + t2;
cout << "t3=t1+t2=" << t3;
t4 = t1 - t2;
cout << "t4=t1-t2=" << t4;
return 0;
}刚开始我将函数声明为：
friend Timer&operator+(Timer&,Timer&);
friend Timer&operator-(Timer&,Timer&);对于<<,>>的重载声明的和长代码一样。但是这样做之后我发现出现异常。
在Time &operator+(Timer&t1,Timer&t2)里我声明了一个Timer的局部变量，而当函数调用结束后，该指针变成了悬挂指针。
所以，一定谨记不要在返回值为引用的函数中返回局部变量。
C++函数返回值和返回引用问题
C++函数的返回过程基本可以分为两个阶段，返回阶段和绑定阶段，根据两个阶段中需要返回的值的类型不同（返回值和引用），和要绑定的值的类型（绑定值和引用）会产生不同的情况。
最基本的规则是先返回，再绑定，返回和绑定的时候，都有可能发生移动或者拷贝构造函数的调用来创建临时对象，并且只会发生一次。更具体的，当返回值的时候，函数返回之前，会调用一次拷贝构造函数或移动构造函数，函数在绑定到值的时候，会发生一次拷贝构造函数或移动构造函数，如果返回时已经调用了构造函数，则绑定时不会再调用，而是直接绑定。返回引用或者绑定到引用，在各自阶段，不会产生构造函数的调用。
下面举例阐述各种可能的情况（例子中很多情况我们是不该这样写的，本文只讨论如果这样做了会怎样）。
关于右值引用和移动构造函数的解释，后面会写篇东西做个总结。这里仅需要一条规则，那就是在需要调用移动构造函数的情况，如果类没有定义移动构造函数，则调用它的拷贝构造函数，后面对未定义移动构造函数的情况，不再赘述。
为叙述方便，定义绑定值和返回值：
绑定值就是函数赋给的变量，返回值就是函数的返回值，最终的调用形式类似：
返回值 fun()
{
.....
return 返回值；
}
绑定值 = func();定义一个类：
class myClass
{
public:
//构造函数
myClass()
{
cout << "construct" << endl;
}
//拷贝构造函数
myClass(const myClass& rhs)
{
cout << "copy construct" << endl;
}
//移动构造函数
myClass(myClass&& rhs)
{
cout << "move consturct" << endl;
}
//析构函数
~myClass()
{
cout << "desctruct" << endl;
}
};1.绑定值类型为值类型
返回值类型为值类型，返回的是局部变量：
在函数返回阶段，调用类的移动构造函数创建返回值，并绑定到绑定值上。移动构造函数的调用发生在函数返回阶段。
例子：
myClass fun()
{
myClass mc;
return mc;
}
int main()
{
myClass result = fun();
}输出：
construct
move consturct
desctruct
desctruct
2.绑定值类型为值类型
返回值类型为值类型，返回的是局部变量的引用：
首先，这不是一个好的做法，企图返回一个局部变量的引用结果通常并不会令人满意。
函数调用结束后，函数帧被回收（实际上只是设置了栈顶的地址），函数栈中的临时变量不再有意义。
但是这么做通常也不会造成什么副作用，因为在函数返回阶段，会调用拷贝构造函数（注意，即使定义了移动构造函数也不会调用），将生成的新的临时对象，绑定到绑定值上。
例子：
myClass fun()
{
myClass mc;
myClass& mcRef = mc;
//如果是想返回这个局部变量的引用，并且在函数外部对其进行修改，那必然要失望了。
return mcRef;
}
int main()
{
myClass result = fun();
}输出：
construct
copy construct
desctruct
desctruct
3.绑定值类型为值类型
返回值类型为值类型，返回的是全局变量的引用：
和2中的情形类似，但是由于全局变量的生命周期超过当前函数，所以即使函数返回，变量仍然存活。在函数返回阶段，仍然会调用拷贝构造函数，将产生得临时对象绑定到绑定值上，却依然不能返回全局对象。
例子：
通常，返回作为参数而传递进来的引用的情况更加常见，此时的参数对于函数来说，和全局变量类似，即函数返回，变量的生命周期也不会结束。
myClass fun(myClass& param)
{
//最终只能得到param的拷贝
return param;
}
int main()
{
myClass mc;
myClass result = fun(mc);
}输出：
construct
copy construct
desctruct
desctruct
4.绑定值类型为值类型
返回值类型为引用类型，返回的是局部变量或局部变量的引用：
和情况2情形类似的是，希望以引用的方式返回局部变量或者局部变量的引用，通常也不能取得令人满意的结果；但与情况2的情形不同的是，情况2基本不会产生什么副作用，情况2中在函数返回阶段对对象进行拷贝，此时对象完整；但是在本情况中，就会产生严重的副作用。
由于返回值类型为引用类型，在函数返回阶段，并不会调用拷贝构造函数，而在绑定阶段，绑定值是值类型，才会产生拷贝构造函数的调用，而此时函数已经返回，拷贝函数拷贝的是函数中的临时变量，此时已经析构了，再进行拷贝，只会得到一个被析构对象的拷贝，通常，这会产生严重的错误。
简单的说，这种情况下，会先析构临时对象，在拷贝这个临时对象。
例子：
myClass& fun()
{
myClass mc;
//或者myClass mcRef = mc; return mcRef
return mc;
}
int main()
{
myClass result = fun();
}输出：
construct
desctruct
copy construct
desctruct
5.绑定值类型为值类型
返回值类型为引用类型，返回的是全局变量的引用：
基本的情况和2是类似的，即并不能真的的到全局变量的引用，但是也不会产生什么副作用（除非调用者就是希望或者这个全局变量，并进行修改）。由于全局变量在函数结束之后并不会被析构，所以对它调用拷贝构造函数是安全的。和情况4类似，拷贝函数的调用也不是发生在函数返回阶段，而是发生在绑定阶段。
例子：
同样使用参数为引用类型的函数举例：
myClass& fun(myClass& param)
{
return param;
}
int main()
{
myClass mc;
myClass result = fun(mc);
}输出：
construct
copy construct
desctruct
desctruct
上述5中情况是将返回值绑定到值类型的情形，所有情形中，均会出现拷贝或移动构造函数的调用，最终绑定之后，都不可能得到原来的对象，企图通过这种方式来修改原对象，必然会失败。
如果绑定值类型为引用类型，返回值类型为值类型，返回的是局部变量，局部变量的引用或者全局变量会怎么样呢？
这种情况编译器会报错，由于函数返回的是值类型，必然会产生移动构造函数或者拷贝构造函数，产生一个临时对象，而临时对象是一个右值，我们常说的引用，其实是左值引用，而一个右值对象是不能够绑定到一个左值引用的，所以编译器会报错。
我们可以将函数的返回值版绑定到右值引用变量（使用myClass&&），我们下面讨论返回右值引用的情况。但是，有时候返回一个右值引用并且使用它，可能并不能产生想要的结果（如本文最后例子）。
6.绑定值类型为右值引用
返回值类型为值类型，返回的是局部变量或局部变量的引用或全局变量的引用：
函数返回阶段，由于是返回值类型，所以会调用移动构造函数或者拷贝构造函数，创建一个不具名的临时变量（其实它就是一个右值），可以把它绑定到一个右值引用上。
但是对它的修改是没有什么意义的，本来函数创建的这个不具名临时变量，会在函数返回之后被析构，由于我们增加了一个指向它的引用，所以这个临时变量的生命周期被延长了，直到指向它的引用离开作用域，它才会析构。
例子：
myClass fun()
{
myClass mc;
return mc;
}
int main()
{
myClass&& result = func();
}输出：
construct
move consturct
desctruct
desctruct
myClass fun()
{
myClass mc;
myClass& mcRef = mc;
return mcRef;
}
int main()
{
myClass&& result = fun();
}输出：
construct
copy construct
desctruct
desctruct
7.绑定值类型为为引用类型
返回值类型为引用类型，返回局部变量或局部变量的引用：
由于函数返回阶段和绑定阶段都是引用类型，所以不会产生任何拷贝或移动构造函数的调用，最终绑定值类就是函数的局部变量，但是由于函数返回后，局部变量已经被析构，在保存这个局部变量的引用没有意义，往往会引起一些诡异的错误。
例子：
myClass& fun()
{
myClass mc;
//或者myClass& mcRef = mc; return mcRef;
return mc;
}
int main()
{
//在函数返回之后，我们甚至还能使用这个result，但是仅仅是编译器将原来result的位置继续解释成result变量，
//很有可能很快这个位置会被新的栈帧覆盖，继续使用result，可能会出现“诡异”的问题
myClass& result = fun();
}输出：
construct
desctruct
8.绑定值类型为引用类型
返回值类型为引用类型，返回全局变量的引用：
通常，当我们这是我们的真实意图，函数在返回阶段和绑定阶段均不存在构造函数的调用，最终绑定值就是需要返回的全局变量，对最终绑定值的任何修改，均会反映到全局变量上。
例子：
依然使用参数为引用类型的函数举例。
myClass& fun(myClass& mc)
{
return mc;
}
int main()
{
myClass mc;
myClass& result = fun(mc);
}输出：
construct
desctruct
9.一个思考
右值是不能绑定到左值引用的，但是当把右值付给左值会怎样呢？
如下
int main()
{
myClass mc;
myClass result = move(mc);
}答案是会调用移动构造函数创建一个新的对象，并且绑定到绑定值。
输出：
construct
move consturct
desctruct
desctruct
另一个非常类似的例子：
int main()
{
myClass mc;
myClass&& mcRightRef = move(mc);
myClass result = mcRightRef;
}和第一个非常类似，但是result的生成是调用拷贝构造函数而非移动构造函数完成的。
输出：
construct
copy construct
desctruct
desctruct
这就涉及到了移动构造函数调用的时机，更多关于右值，右值引用和移动构造函数详细的研究，待续。