刷知乎的时候看到这个问题，C++函数返回值拷贝问题？，觉得有趣，因此写了这篇博客。
函数如何返回值
函数返回值的传递分为两种情况。
- 当返回的对象的大小不超过8字节时，通过寄存器（eax edx）返回。
- 当返回的对象的大小大于8字节时，通过栈返回。但是，如果返回struct/class对象，尽管其大小不大于8字节，也是通过栈返回的。
在通过栈返回的时候，栈上会有一块空间来保存函数的返回值。当函数结束的时候，会把要返回的对象拷贝到这块区域，对于内置类型是直接拷贝，类类型的话是调用copy ctor。这块区域又称为函数返回的临时对象（temporary object）。
下面用代码看一下是不是这样。
首先，编写Base类和func()函数。
struct Base{
Base() { cout << "default ctor" << endl; };
Base(const Base& b) { cout << "copy ctor " << endl; }
Base& operator=(const Base& b){ cout << "operator=" << endl; a = b.a; return *this;}
~Base(){cout << "dtor " << endl;};
int a = 0;
};
Base func(){
Base a;
return a;
}
调用函数：（为了确保临时对象的存在，我绑定一个const引用到它上面；其实不绑定的话，直接func();也会有临时对象的存在）
const Base &r = func();
输出
default ctor
dtor
按理说，存在临时对象，输出应该是
default ctor
copy ctor
dtor
dtor
因为这里C++做了返回值优化（RVO）。RVO是一种编译器优化的技术，它把要返回的局部变量直接构造在临时对象所在的区域，达到少调用一次copy ctor的目的。
为了避免RVO，把func()重新编写。这样编译器不清楚哪个局部变量会被返回，所以就避免了返回值优化。
Base func(int i){
if(i > 0) {
Base a;
return a;
}
else{
Base b;
return b;
}
}
调用func:
func(0);
输出
default ctor // 函数内的局部对象
copy ctor //局部对象->临时对象
dtor // 局部对象析构
dtor // 临时对象析构
结果符合预期。
如果这样调用：
Base a = func(0);
输出：
default ctor // 函数内的局部对象
copy ctor // ？
dtor // 局部对象析构
dtor // ？
为何是这样？不应该是还有一次临时对象到a的copy ctor和a的dtor吗？
这里我猜测进行了另外的优化，将两者合并到了一起，也就是把a的存储区域作为临时对象的区域。
下面这样调用：
Base a = func(0);
cout << endl;
a = func(0);
输出是：
default ctor // func的局部对象
copy ctor // func的局部对象->临时对象
dtor // func的局部对象析构
default ctor // func的局部对象
copy ctor // func的局部对象->临时对象（也就是a）
dtor // func的局部对象析构
operator= // 临时对象->a
dtor // 临时对象析构
dtor // a析构
输出十分合理！
RVO
RVO，是Return Value Optimization。这是在函数返回返回值的时候编译器所做出的优化，是C++11标准的一部分，C++11称之为copy elision。
在第一次编写的func里面，编译器明确知道函数会返回哪一个局部对象，那么编译器会把存储这个局部对象的地址和存储返回值临时对象的地址进行复用，也就是说避免了从局部对象到临时对象的拷贝操作。这就是RVO。
现在把func重新改为：
Base func(){
Base b;
return b;
}
以下面三种方式调用func。
func();
cout << endl;
Base a = func();
cout << endl;
a = func();
输出
default ctor // 局部对象b（也是临时对象）的构造
dtor
default ctor // 局部对象b（也是临时对象，也是要初始化的对象a）的构造
default ctor // 局部对象b（也是临时对象）的构造
operator= // 局部对象b（也是临时对象）-> 对象a
dtor // 局部对象b
dtor // 对象a
输出十分合理！
std::move()
在查阅RVO的资料的时候，看到了这篇博客RVO V.S. std::move，讲的特别好。除了RVO里面还提到了std:move()，为了加深对std::move的理解，我又做了下面几个实验。
重新编写func：
Base func(){
Base b;
return std::move(b);
}
然后向Base添加下面的成员：
Base& operator=(Base&& b){ cout << "move operator=" << endl; a = b.a; return *this;}
Base(Base&& b) { cout << "move ctor" << endl;}
调用：
func();
cout << endl;
Base a = func();
cout << endl;
a = func();
输出：
default ctor // 局部对象b
move ctor // 局部对象b向临时对象的移动
dtor
dtor
default ctor // 局部对象b
move ctor // 局部对象b向临时对象（也是要初始化的对象a）的移动
dtor
default ctor // 局部对象b
move ctor // 局部对象b向临时对象的移动
dtor // 局部对象b析构
move operator= // 临时对象到a的移动，临时对象是右值，所以用move
dtor // 临时对象析构
dtor
func的函数返回类型仍然是Base，而不是Base&&。这意味着函数还是会创建一个Base类的临时对象，只是临时对象是通过右值引用得到的，也就是说通过移动构造函数移动得到的。
把func的返回类型改为Base&&：
Base&& func(){
Base b;
return std::move(b);
}
还是调用，
func();
cout << endl;
Base a = func();
cout << endl;
a = func();
输出：
default ctor // 局部对象
dtor
default ctor // 局部对象
dtor // 局部对象
move ctor // 局部对象到a的移动（注意：因为这里局部对象已经析构，所以这里的行为是undefined，十分危险）
default ctor // 局部对象
dtor // 局部对象
move operator= // 局部对象到a的移动
dtor
总结
函数的返回类型是类类型，return局部对象，可能会有RVO；
函数的返回类型是类类型，return右值引用，肯定不会有RVO；
函数的返回类型是右值引用，return右值引用，没有临时对象的消耗，但是仍不可取，因为右值引用的对对象在使用前已经析构了。
Reference
- RVO V.S. std::move
- Understanding stack frame of function call in C/C++?
- Scope and return values in C++