一、右值引用

1.左值和右值

左值与右值是C语言就有的概念，但C语言并没有给出严格的区分方式，一般认为，可以放在赋值符号左边的值就是左值，只能放在赋值符号右边的值就是右值。

int main()
{
    
    // 下面a、b都是左值
    int a = 10;
    double b = 1.0;

    // 下面a+b、10都是右值
    a + b;
    10;

    return 0;
}

然而，这种区分方式不是完全正确，存在一些矛盾的地方，比如下面的例子，变量b可以在赋值符号左边，也可以在赋值符号右边，但变量b并不是右值而是左值。

int main()
{
    
    // 下面a、b都是左值
    int a = 10;
    double b = 1.0;
	
	// b在赋值符号右边
    a = b;

    return 0;
}

所以，区分左值和右值最好的方式就是看这个值(或者表达式)可不可以取地址，如果可以取地址那就是左值，不可以取地址那就是右值。

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址，也可以对它进行赋值，左值可以出现在赋值符号左边，也可以出现在赋值符号右边。这里有一个特例就是const修饰的变量，我们虽然不能对它进行赋值，但是我们可以获取它的地址，所以const修饰的变量也是左值。

int main()
{
    
    // 以下的指针变量p、指针变量的解引用*p、b和c都是左值
    int* p = new int(1);
    int b = 0;
    const int c = 1;
    return 0;
}

右值也是一个表示数据的表达式，比如字面常量、表达式返回值、函数返回值(这个返回值不能是左值引用返回，必须是传值返回，因为传值返回会生成临时变量)等等，右值只能出现在赋值符号的右边，不能出现在赋值符号的左边。右值不能取地址。

int Add(int a, int b)
{
    
    return a + b;
}

int main()
{
    
    int x = 1, y = 2;

    // 以下几个就是常见的右值
    10;// 字面常量
    x + y;// 表达式返回值
    Add(x, y);// 函数传值返回的返回值
    return 0;
}

2.左值引用和右值引用

左值引用就是对左值取别名，右值引用就是对右值取别名。

int Add(int a, int b)
{
    
    return a + b;
}

int main()
{
    
    // 以下的指针变量p、指针变量的解引用*p、b和c都是左值
    int* p = new int(1);
    int b = 0;
    const int c = 1;

    // 左值引用
    int*& rp = p;
    int& rb = b;
    const int& rc = c;
    int& rpValue = *p;

    int x = 1, y = 2;

    // 以下几个就是常见的右值
    10;// 字面常量
    x + y;// 表达式返回值
    Add(x, y);// 函数传值返回的返回值

    // 右值引用
    int&& rr1 = 10;
    int&& rr2 = (x + y);
    int&& rr3 = Add(x, y);

    return 0;
}

需要注意右值引用还有一个特性，右值是不能够取地址的，但是给右值取别名以后，会导致右值被存储到了特定的位置，就可以取地址了。比如上面代码中的字面常量10是不能取地址的，但是rr1引用了之后，就可以对rr1取地址了，也可以修改rr1的值。如果不想rr1被修改，就要将rr1设置成const右值引用。

3.左值引用和右值引用的总结

左值引用只能引用左值，不能引用右值，但这里也有一个例外，const的左值引用既可以引用左值，也可以引用右值。这也是我们在设计函数参数的时候尽量设计成const左值引用的原因，因为无论是左值还是右值都可以传递进去。

int main()
{
    
    // 左值引用只能引用左值，不能引用右值
    int a = 10;
    int& ra = a;
    //int& rb = 10;// 编译报错，不能引用右值

    // const左值引用可以引用左值
    const int& ra1 = a;
    // const左值引用也可以引用右值
    const int& ra2 = 10;
    return 0;
}

右值引用只能引用右值，不能引用左值。但是右值引用可以引用move之后的左值。

int main()
{
    
    // 右值引用只能引用右值，不能引用左值
    int&& r1 = 10;
    int a = 10;
    // int&& r2 = a;// 编译报错，右值引用不能引用左值

    // 右值引用可以引用move之后的左值
    int&& r3 = move(a);
    return 0;
}

4.右值引用使用场景

右值引用的提出就是为了弥补左值引用的不足，我们以模拟实现string类为例，来研究一下左值引用存在哪些不足之处。

例如在模拟实现string类的时候，我们模拟实现to_string函数时，如果没有右值引用的话，我们只能用左值引用来解决深拷贝问题。

然而to_string函数在实现时定义了str这个临时变量，最后要返回str这个临时变量。所以我们没办法在这个地方使用左值引用，因为str这个临时变量出了作用域就会销毁，如果我们取它的别名返回，就会出现野指针错误。

所以在这个地方不得不使用传值返回。传值返回就会带来深拷贝的问题，并且在这个地方，str在被销毁之前编译器会创建一个临时变量来存储str的内容，然后再销毁str，最后返回的是临时变量的对象。这里就会存在多次深拷贝问题，效率是非常低的。

(1)移动构造

要解决这个问题我们可以采用移动构造，即再提供一个右值引用版本的拷贝构造函数。

string(string &&s)
	: _str(nullptr), _size(0), _capacity(0)
{
    
	swap(s);
}

移动构造的本质就是参数s是右值，将右值的资源直接交换给this，占为己有，那么就不用做深拷贝了，所以它叫作移动构造，就是将别人的资源移动过来构造自己。

这里就会有一个问题：为什么一定要右值引用才可以这样呢？原来左值引用版本的拷贝构造函数为什么不可以直接将this对象与s对象做交换呢？

这里我们将左值引用版本的拷贝构造函数和右值引用版本的拷贝构造函数拿出来做一个对比：左值引用版本的拷贝构造函数，它的参数必须是const修饰的，所以s是一个左值引用，如果我们直接让swap(s)交换，swap函数的参数就必须设置成const修饰的，否则就是权限放大编译会报错。

但是swap函数的参数设置成const修饰的话又不能对s进行修改了，也就无法完成交换了，所以左值引用版本的拷贝构造函数必须先使用构造出一个tmp对象，再让tmp对象与this进行交换。

(2)移动构造前后的区别

我们首先来看一下如果没有移动构造，只提供左值引用版本的拷贝构造函数，调用to_string函数会怎么样？

我们在左值引用版本的拷贝构造中输出一些信息方便我们查看调试：

我们可以先来猜测一下：to_string函数的返回值str是一个左值，它出了函数作用域就会被销毁，所以它先会拷贝构造给一个临时变量，临时变量是一个右值，它会拷贝构造给ret变量，所以应该要进行两次拷贝构造。

我们再运行代码测试一下：结果显示只有一次深拷贝，并没有像我们猜测的那样进行两次深拷贝。

这里的原因是编译器进行了优化，由于str、临时变量、ret都具有相同的内容，但各自却拥有不同的空间，所以这样是很浪费内存空间的，编译器优化了之后是直接一次拷贝构造将str深拷贝给ret。

我们再来看一下提供了移动构造之后，调用to_string函数又会怎么样？

同样的，我们也在右值引用版本的拷贝构造中输出一些信息方便我们查看调试：

我们可以再猜测一下：to_string函数的返回值str是一个左值，临时变量是一个右值，所以str会拷贝构造给临时变量，临时变量再移动构造给ret。最后应该会先调用一次拷贝构造，再调用一次移动构造。

我们运行代码测试一下：结果又不是像我们猜测的那样，它只有一次移动构造，并没有调用拷贝构造。

这里的原因也是编译器进行了优化，编译器将str变成了右值，直接移动构造给ret，并没有生成临时变量。

针对移动构造函数和移动赋值运算符重载有下面这些点需要注意：

1. 如果我们没有自己实现移动构造函数，且没有实现析构函数、拷贝构造函数、赋值运算符重载中的任意一个函数，那么编译器会自动生成一个默认的移动构造函数。
2. 默认生成的移动构造函数，对于内置类型的成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用它的移动构造函数，否则调用它的拷贝构造函数。(移动运算符重载函数与之完全类似)
3. 如果我们没有自己实现移动运算符重载函数，且没有实现析构函数、拷贝构造函数、赋值运算符重载中的任意一个函数，那么编译器会自动生成一个默认的移动运算符重载函数。

如果我们实现了拷贝构造函数，不构成默认生成移动构造的条件，在C++11中我们可以使用default关键字强制生成默认成员函数。

// 强制生成默认移动构造函数
Person(Person&& p) = default;

相反，如果我们想要限制某些默认函数的生成，C++11可以在该函数声明后面加上delete关键字，该语法指示编译器不生成对应函数的默认版本。

// 不生成默认的拷贝构造函数
Person(const Person& p) = delete;

二、完美转发

如果是模板中的&&不代表右值引用，而是完美引用。它既能接收左值也能接收右值。例如下面的代码例子：我们使用了完美引用，既然它能接收左值也能接收右值，那我们分别传递右值、左值、右值、const左值、const右值进入函数，看看结果是什么。

#include <iostream>

using namespace std;

void Fun(int &x) {
     cout << "左值引用" << endl; }
void Fun(const int &x) {
     cout << "const 左值引用" << endl; }
void Fun(int &&x) {
     cout << "右值引用" << endl; }
void Fun(const int &&x) {
     cout << "const 右值引用" << endl; }

template <typename T>
void PerfectForward(T &&t)
{
    
    Fun(t);
}
int main()
{
    
    PerfectForward(10); // 右值
    int a;
    PerfectForward(a);            // 左值
    PerfectForward(std::move(a)); // 右值
    const int b = 8;
    PerfectForward(b);            // const 左值
    PerfectForward(std::move(b)); // const 右值
    return 0;
}

运行程序查看结果我们发现，无论是左值还是右值，最后都变成了左值。

原因是模板的万能引用只是提供了能够同时接收左值和右值的能力，但传递进来之后会发生引用折叠，右值会被转换成左值，const右值会被转换成const左值。

如果我们希望在传递过程中保持左值和右值的属性不变，就需要用到完美转发机制。

std::forward<>()函数可以在传参过程中保留对象的原生类型属性。

#include <iostream>

using namespace std;

void Fun(int &x) {
     cout << "左值引用" << endl; }
void Fun(const int &x) {
     cout << "const 左值引用" << endl; }
void Fun(int &&x) {
     cout << "右值引用" << endl; }
void Fun(const int &&x) {
     cout << "const 右值引用" << endl; }

template <typename T>
void PerfectForward(T &&t)
{
    
    Fun(std::forward<T>(t));
}
int main()
{
    
    PerfectForward(10); // 右值
    int a;
    PerfectForward(a);            // 左值
    PerfectForward(std::move(a)); // 右值
    const int b = 8;
    PerfectForward(b);            // const 左值
    PerfectForward(std::move(b)); // const 右值
    return 0;
}

在使用了完美转发以后我们再来运行程序查看结果，这次就不再发生类型转换了。