1 右值引用

1.1 左值 、 右值

在C++中所有的值不是左值就是右值。左值是指表达式结束后依然存在的持久化对象，右值是指表达式结束后就不再存在的临时对象。有名字的对象都是左值，右值没有名字。

区分左值和右值最便捷的方法就是看能不能对表达式取地址。如果能，则为左值，否则就是右值。

---

C++11扩展了右值的概念，将右值分为纯右值和将亡值

纯右值

1.非引用返回的临时对象
2.运算表达式产生的结果
3.字面常量（C风格字符串除外，它是地址）

将亡值

与右值引用相关的表达式。
例如：将要被移动的对象，T&&的函数返回值，std::move()的返回值,转换成T&&类型的转换函数的返回值

左值右值代码示例：

class A
{
public:int a;
};
A getTemp()
{return A();
}int i = 3; //i是左值，3是右值int j = i + 8;//j是左值，i+8是右值A a1 = getTemp();//a1是左值，getTemp()返回的临时变量是右值引用

1.2 左值引用 VS 右值引用

在C++98中的引用是左值引用，就是给变量取个别名。在C++11中，因为新增了右值引用的概念，所有把C++98中的引用都称为左值引用。

右值引用就是给右值取个名字
语法：

数据类型&& 变量名 = 右值;

代码示例：

#include <iostream>using namespace std;class A
{
public:int m_a = 9;
};
A getTemp()
{return A();
}
int main()
{int&& a = 3;//3是右值int b = 8;//b是左值int&& c = b + 5;//b+5 是右值A&& aa = getTemp();//getTemp的返回值是右值（临时变量）cout << "a=" << a << endl;//3cout << "c=" << c << endl;//13cout << "aa.m_a=" << aa.m_a << endl;//9return 0;
}

值得一提的是，右值有了名字之后，就成了普通变量，普通变量有名字就可以取地址。
所以上述代码中：
a,c,aa均可以看成是左值

我们可以用代码验证一下：
对左值进行运算：

	int&& a = 3;//3是右值a++;int b = 8;//b是左值int&& c = b + 5;//b+5 是右值c++;A&& aa = getTemp();//getTemp的返回值是右值（临时变量）aa.m_a++;cout << "a=" << a << endl;//4cout << "c=" << c << endl;//14cout << "aa.m_a=" << aa.m_a << endl;//10

对左值取地址

也可以像普通引用一样加const约束

1.3 谈谈C++11引入右值引用的意义

在上述代码中，getTemp()的返回值在表达式语句结束之后也就该终结了（因为是临时变量），而通过右值引用获得了新生，其生命周期将与右值引用aa的生命周期一样，只要aa还活着，该右值临时变量将会一直活下去。

引入右值引用的主要目的是实现移动语义（后面会讲）

1.4 左值引用和右值引用的一些细节问题

左值引用只能绑定(关联、指向)左值，右值引用只能绑定(关联、指向)右值，如果绑定的不对，编译失败。

错误代码示例：
把上述代码的右值引用改为左值引用

int& a = 3;//错误代码，3是右值
int& c = b + 5;错误代码，b+5 是右值
A& aa = getTemp();//，错误代码，getTemp的返回值是右值（临时变量）

错误代码示例：
错误使用右值引用

int&& c = b;//错误代码，b是左值，却用了右值引用

---

万能引用类型 ： 常量左值引用

常量左值引用可以算是一个万能的引用类型，它可以绑定非常量左值，常量左值，右值，而且在绑定右值的时候，常量左值引用一样将右值的生命周期延长，缺点是只能读，不能改。

在笔者之前写过一篇关于常量左值引用
常量左值引用的一些经典问题

在C++引入了右值引用以后，能更方便地解决了这些问题。

代码示例：

	int a = 1;const int& ra = a;//a是非常量左值const int b = 1;const int& rb = b;//b是常量左值const int& rc = 1;//1是右值

2 移动语义

如果一个对象中有堆区资源，需要编写拷贝构造函数和赋值函数，实现深拷贝。
深拷贝把对象中的堆区资源复制了一份，如果源对象（被拷贝的对象）是临时对象，拷贝完就没什么用了，这样会造成没有意义的资源申请和释放操作。如果能够直接使用源对象拥有的资源，可以节省资源申请和释放的时间。C++新增的移动语义就能够做到这一点。

实现移动语义要增加两个函数：移动构造函数和移动赋值函数。

移动构造函数的语法：

类名（类名&& 源对象）{…}

移动赋值函数的语法：

类名&operator=(类名&& 源对象){…}

代码示例：
我们先写出不用右值引用的拷贝构造函数和赋值函数

#include <iostream>
#include <utility>
using namespace std;class AA
{
public:AA(int* _m_data):m_data(new int[sizeof(_m_data)])//开辟空间{*m_data = *_m_data;//赋值}AA(){}AA(const AA& a)//拷贝构造函数:m_data(nullptr){cout << "调用了拷贝构造函数" << endl;AA tmp(a.m_data);swap(tmp);}AA& operator=(const AA& a){cout << "调用了赋值函数" << endl;if (this != &a)//避免自我赋值{AA tmp(a.m_data);swap(tmp);}return *this;}void swap(AA& a){std::swap(m_data, a.m_data);//库里面的交换函数}~AA(){delete m_data;m_data = nullptr;}
public:int* m_data = nullptr;//数据成员，指向堆区资源的指针
};int main()
{int t = 3;AA a1(&t);//创建一个对象a1cout << "a1.m_data=" << *a1.m_data << endl;AA a2 = a1;//将调用拷贝构造函数cout << "a2.m_data=" << *a2.m_data << endl;AA a3;a3 = a1; //将调用赋值函数cout << "a3.m_data=" << *a3.m_data << endl;return 0;
}

其中我们拷贝构造函数和赋值函数采用了现代写法：先创建一个临时对象，临时对象会调用一次次有参构造，申请内存资源，然后将该临时对象与this指针交换即可完成我们的拷贝构造。赋值函数同理。

不管是传统的写法还是现代的写法，都需要再申请一份堆区的资源，这份申请的资源被拷贝完后就没什么用了，造成了资源的浪费。于是就有了我们的移动语义。

AA(const AA& a)//拷贝构造函数:m_data(nullptr){cout << "调用了拷贝构造函数" << endl;AA tmp(a.m_data);swap(tmp);}AA(AA&& a)  //移动构造函数:m_data(nullptr)       {cout << "使用了移动语义" << endl;swap(a);//直接交换即可，不用再申请空间}

注意：移动构造函数的函数参数里不能加const,因为我们要对a这个对象的值进行修改。

这是交换前：

交换后：

赋值函数也同理：

AA& operator=(const AA& a) //赋值函数{cout << "调用了赋值函数" << endl;if (this != &a)//避免自我赋值{AA tmp(a.m_data);swap(tmp);}return *this;}AA& operator=(AA&& a)//移动赋值函数{cout << "调用了移动语义" << endl;if (this != &a)//避免自我赋值{swap(a);}return *this;}

我们运行一下代码试试：

注意事项：
1.对于一个左值，会调用拷贝构造函数，但是有些左值是局部变量，生命周期也很短，能不能也移动而不是拷贝呢？(就是我们的演示代码)C++11为了解决这个问题，提供了std::move()方法来讲左值转义为右值，从而方便使用移动语义。它其实就是告诉编译器，虽然我是一个左值，但不要对我使用拷贝函数，而是用移动构造函数。左值对象被转移资源后，不会立刻析构，只有在离开自己的作用域的时候才会析构，如果继续使用左值中的资源，可能会发生意想不到的错误。
2.如果没有提供移动构造/移动赋值函数，只提供了拷贝构造/赋值函数，编译器找不到移动构造/移动赋值函数就去寻找拷贝构造/赋值函数。
3.C++11中的所有容器都实现了移动语义，避免对含有资源的对象发生无谓的拷贝。
4.移动语义对于拥有资源（如内存、文件句柄）的对象有效，如果是基本类型，使用移动语义没有意义。

3 完美转发

在讲完美转发之前，我们先来看这样一个问题。

如下的代码，我们想要的结果是让fun(a)调用fun1(int& ii) 这个函数，fun(8)调用fun1(int&& ii)这个函数，但是通过一个函数中转调用，编译器都会认为是左值。

void fun1(int& ii) //参数如果是左值，调用此函数
{cout << "参数是左值=" << ii << endl;
}
void fun1(int&& ii) //参数如果是右值，调用此函数
{cout << "参数是右值=" << ii << endl;
}void fun(int i) //通过该函数调用fun1
{fun1(i);
}
int main()
{int a = 3;fun(a);//a是左值fun(8);//8是右值return 0;
}

那如果我们把代码改成这样：

void fun(int& i) //通过该函数调用fun1
{fun1(i);
}

fun(8)这行代码就会报错，因为8是右值

同理，把代码改成这样：

void fun(int&& i) //通过该函数调用fun1
{fun1(i);
}

无法将左值绑定到右值引用

解决方案
我们重载一份fun函数，一份左值引用，一份右值引用。
右值引用的的fun()在调用fun1的时候，把i利用move函数改成右值

void fun(int& i) //通过该函数调用fun1
{fun1(i);
}
void fun(int&& i) //通过该函数调用fun1
{fun1(move(i));
}

---

如果上述代码是以函数模板的形式写的，那么C++11有了更完美的解决方案，就是完美转发。
原代码

template <class T> 
void fun(T& i) //通过该函数调用fun1
{fun1(i);
}
template <class T>
void fun(T&& i) //通过该函数调用fun1
{fun1(move(i));
}
int main()
{int a = 3;fun(a);//a是左值fun(8);//8是右值return 0;
}

上述的重载了两个函数模板，反而违背了模板的理念。所以，利用C++11完美转发优化后的代码如下：

void fun1(int& ii) //参数如果是左值，调用此函数
{cout << "参数是左值=" << ii << endl;
}
void fun1(int&& ii) //参数如果是右值，调用此函数
{cout << "参数是右值=" << ii << endl;
}template <class T>
void fun(T&& i) //注意这里:左值为什么也能绑定到右值？
{fun1(forward<T>(i));//完美转发
}
int main()
{int a = 3;fun(a);//a是左值fun(8);//8是右值return 0;
}

在函数模板中，可以将参数“完美”的转发给其他函数。所谓完美，即不仅能准确的转发参数的值，还能保住被转发参数的左、值属性不变。
C++11标准引入了右值引用和移动语义，所以，能否实现完美转发，决定了该参数在传递过程中使用的是拷贝语义还是移动语义。
为了支持完美转发，C++11提供了以下方案：

引用折叠（模板参数才能使用）

如果模板中（包括类模板和函数模板）函数的参数书写成为T&&，那么，函数既可以接受左值引用，又可以接受右值引用。

std::forward<T> 参数

提供了函数模板 std::forward<T>(参数)，用于转发参数，如果参数是一个右值，转发之后仍是右值引用；如果参数是一个左值，转发之后仍是左值引用。

4 总结

以上就是右值引用/移动语义/完美转发的解释。C++11引入引入右值引用是为了给移动语义和完美转发服务的。移动语义的移动拷贝和移动赋值为我们避免了内存资源的浪费，完美转发解决了代码的冗余。