转自
https://www.cnblogs.com/jianhui-Ethan/p/4665573.html
C++11 引入的新特性中，除了并发内存模型和相关设施，这些高帅富之外，最引人入胜且接地气的特性就要属『右值引用』了（rvalue reference）。加入右值引用的动机在于效率：减少不必要的资源拷贝。考虑下面的程序：
std::vector<string> v;
v.push_back("string");
首先看push_back：
push_back(const T& x)
实际上传进来的是引用
而在push_back中构造时，使用的是construct:
void construct(T1* p,const T2& value)
{
new(p) T1(value);
}
T1*为迭代器所指的位置，而构造的值value也是引用。T1为迭代器类型，而p为该迭代器所处的地址，也就是说construct实际上是在迭代器所属位置上，用value来构造一个T1类型的迭代器。
这里值得要注意的是，容器对其中存储元素的管理都是在堆上的（用自由存储区更精确），也就是说容器本身可能是在栈上，但它管理的元素一定是在堆上。
在回到上面的过程：
首先"string"这是一个char*指向的区域，而push_back调用的实际上里面是一个string&变量，因此首先进行隐式转换，调用string的string(const char*)这个含参的构造函数。
而这个生成的变量其实上是一个临时变量。
push_back可以看到他是传参的，因此这个临时变量直接被传进去而没有被拷贝构造。
到目前为止，使用了隐式转换，而这次隐式转换调用了含参(char*)的string的构造函数。
进入之后进入construct,而construct也是传引用，因此这里也没有调用构造。
但是在construct内部，在new时，使用了T1的含参构造，相当于在堆上利用这个临时变量构造了一个T1类型的变量
在这里调用了一次构造。
而由于vector的迭代器是原始指针，因此这里T1与T2是同一种类型（当然对其他容器就不一定是这样了）
因而调用的实际上是拷贝构造
在堆上构造完毕后，construct退栈，push_back退栈，然后这个临时变量因为离开作用域而被析构
实际上这个过程经历了一次含参构造，一次拷贝构造，一次析构
std::vector<string> v;
v.push_back("string");
移动语义：
上面程序操作的问题症结在于，临时对象的构造和析构带来了不必要的资源拷贝。如果有一种机制，可以在语法层面识别出临时对象，在使用临时对象构造新对象（拷贝构造）的时候，将临时对象所持有的资源『转移』到新的对象中，就能消除这种不必要的拷贝（将“string”直接转移给construct构造处的新对象）。这种语法机制就是『右值引用』，相对地，传统的引用被称为『左值引用』。左值引用使用 ‘&’ 标识（比如 string&），右值引用使用 ‘&&’ 标识（比如 string&&）。顺带提一下什么是左值（lvalue）什么是（rvalue）：可以取地址的具名对象是左值；无法取值的对象是右值，包括匿名的临时对象和所有字面值（literal value）。有了右值的语法支持，为了实现移动语义，需要相应类以右值为参数重载传统的拷贝构造函数和赋值操作符，毕竟哪些资源可以移动、哪些只能拷贝只有类的实现者才知道。对于移动语义的拷贝『构造』，一般流程是将源对象的资源绑定到目的对象，然后解除源对象对资源的绑定；对于赋值操作，一般流程是，首先销毁目的对象所持有的资源，然后改变资源的绑定。另外，当然，与传统的构造和赋值相似，还要考虑到构造的异常安全和自赋值情况。作为演示：
其中，重载了String的"=",使遇到使用右值来进行构造时，转移对象的资源。
class String {
public:
String(const String &rhs) { ... }
String(String &&rhs) {
s_ = rhs.s_;
rhs.s_ = NULL;
}
String& operator=(const String &rhs) { ... }
String& operator=(String &&rhs) {
if (this != &rhs) {
delete [] s_;
s_ = rhs.s_;
rhs.s_ = NULL;
}
return *this;
}
private:
char *s_;
};
值得注意的是，一个绑定到右值的右值引用是『左值』，因为它是有名字的。考虑：
其中，D的构造函数重载了一个右值引用版本，在这个版本中使用了初始化列表来初始化基类，但B(rhs)中rhs实际上是个左值，也就是说对B调用构造时将会调用拷贝构造版本，而不是B的移动构造版本
class B {
public:
B(const B&) {}
B(B&&) {}
};
class D : public B {
D(const D &rhs) : B(rhs) {}
D(D &&rhs) : B(rhs) {}
};
D getD();
D d(getD());
上面程序中，B::B(B&&) 不会被调用。为此，C++11 中引入 std::move(T&& t) 模板函数，它 t 转换为右值：
class D : public B {
D(D &&rhs) : B(std::move(rhs)) {}
};
绑定规则
引入右值引用后，『引用』到『值』的绑定规则也得到扩充：
- 左值引用可以绑定到左值: int x; int &xr = x;
- 非常量左值引用不可以绑定到右值: int &r = 0;
- 常量左值引用可以绑定到左值和右值：int x; const int &cxr = x; const int &cr = 0;
- 右值引用可以绑定到右值：int &&r = 0;
- 右值引用不可以绑定到左值：int x; int &&xr = x;
- 常量右值引用没有现实意义（毕竟右值引用的初衷在于移动语义，而移动就意味着『修改』）。
考虑下面这段代码：
当调用不同的构造函数时，会输出不同的语句
class HasPtrMem{
public:
HasPtrMem():d(new int(3))
{
cout<<"Construct:"<<++n_cstr<<endl;
}
HasPtrMem(const HasPtrMem& tmp):d(new int(3))
{
cout<<"copy constructor:"<<++n_cptr<<endl;
}
HasPtrMem(HasPtrMem&& h)
{
d=h.d;
h.d=nullptr;
cout<<"move constructor:"<<++n_mvtr<<endl;
}
~HasPtrMem()
{
delete d;
cout<<"destruct:"<<++n_dstr<<endl;
}
int * d;
static int n_cstr;
static int n_dstr;
static int n_cptr;
static int n_mvtr;
};
int HasPtrMem::n_cstr=0;
int HasPtrMem::n_dstr=0;
int HasPtrMem::n_cptr=0;
int HasPtrMem::n_mvtr=0;
HasPtrMem GetTemp()
{
HasPtrMem n;
return n;
}
int main() {
HasPtrMem a=GetTemp();//a
//HasPtrMem a;//b1
//a=GetTemp;//b2
//GetTemp//c
cout<<endl;
}
我们分别执行a,b1与b2和c:
执行a时:
分析一下这个过程，首先进入GetTemp,生成一个n，此处调用默认构造函数
然后返回n，在返回n的时候，理论上应该生成一个临时变量，此处应该是编译器优化过了，将a当做这个临时变量直接进来构造。
而此处是调用的移动构造函数，尽管n是一个左值，难道说对临时变量的构造都是调用的移动构造函数吗？？？
构造完毕后，析构掉这个n
执行b1,b2时：
分析一下这个过程，首先创建a,此时调用默认构造函数。
然后进入GetTemp内部，首先创建n，此处调用默认构造函数。
由于我们这里是使用的赋值函数，因此不会像上面一样进行优化。
首先用n移动构造一个临时变量，构造完毕后n析构。
然后用这个临时变量复制给a,由于我们没有重载=，因此此处用的默认的赋值函数。
最后临时变量析构
执行c时：
我们分析一下这个过程
注意这里与a的区别，由于这里只调用了GetTemp,因此编译期是无法优化的。
首先创建n,调用默认构造函数
然后调用移动构造去构造临时变量
然后n析构
最后临时变量析构
对于b1,b2,当我们加上移动赋值函数后：
HasPtrMem& operator=(HasPtrMem&& s)
{
d=s.d;
s.d=nullptr;
cout<<"move operator=:"<<endl;
return *this;
}
结果为：
我们分析这个过程，前面不表。
在临时变量调用移动构造函数构造完毕后，n析构。
然后对a,调用了移动赋值函数，然后临时变量析构。
看完上面，有一个问题是：
难道对临时变量的构造一定使用移动构造函数吗？这里的n是一个左值！