一.左值与右值

左值：可以取地址的表示数据的表达式，左值可以出现在赋值符号左边

右值：不能取地址的表示数据的表达式，右值不能出现在赋值符号左边

int fun()
{return 0;
}
int main()
{int a = 0;//a->左值const int b = 1;//b->左值int* p = &a;//*p->左值a + b;//右值func();//右值10;//右值
}

二.左值引用与右值引用 

左值引用：给左值取的别名，符号：type&

1. 左值引用只能引用左值，不能引用右值
2. 但是const左值引用既可引用左值，也可引用右值

右值引用：给右值取的别名,，符号：type&&0

1. 右值引用只能右值，不能引用左值
2. 但是右值引用可以move以后的左值

无论左值引用还是右值引用，都是在取别名，理论上来说不会开辟额外的空间

int a = 0, b = 0;
int& ref1 = a;//左值引用给左值取别名
const int& ref2 = a + b;//临时对象具有常性,左值引用想要绑定右值要将上const
int&& ref3 = a + b;//右值引用给右值取别名
int&& ref4 = move(a);//右值引用给move以后的左值取别名

说明：右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址。例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。

三.使用引用减少拷贝

当函数传参或者传返回值时，传的是自定义类型对象，如果处理不当，将会发生多次拷贝，尤其是需要深拷贝的类，大大降低效率，使用引用就可以有效解决这些问题。

1.左值引用减少拷贝

1. 引用传参
2. 传引用返回

左值引用的短板：当函数返回对象是局部对象，出作用域就会被销毁，此时只能传值返回，倘若该对象需要深拷贝，付出的代价是很大的。

为了解决这一问题，右值引用在C++11应运而生。

2.右值引用减少拷贝

(1)深拷贝的类DeepCopy

class DeepCopy
{
public:DeepCopy(int* p):_p(p){}~DeepCopy(){delete[] _p;}
private:int* _p;
};int main()
{DeepCopy d1 (new int[5]{ 1, 2, 3, 4, 5 });DeepCopy d2 = d1;return 0;
}

DeepCopy类就是一个需要深拷贝的类，因为它的成员着管理一块资源，析构时需要释放资源。如果使用编译器提供的浅拷贝构造，会导致同一块空间释放两次，因此需要我们自己提供深拷贝构造，同样，赋值也需要自己提供。

    DeepCopy(const DeepCopy& d){_p = new int[d._n];_n = d._n;for (int i = 0; i < _n; i++){_p[i] = d._p[i];}cout << "拷贝构造" << endl;}DeepCopy& operator=(const DeepCopy& d){if (this != &d){delete[] _p;_n = d._n;_p = new int[_n];for (int i = 0; i < _n; i++){_p[i] = d._p[i];}}cout << "拷贝赋值" << endl;return *this;}

(2)传值返回发生拷贝构造

传值返回的场景：

DeepCopy Fun()
{DeepCopy d(new int[3]{ 1,2,3 }, 3);return d;
}
int main()
{DeepCopy d1 = Fun();return 0;
}

 

整个过程如下：

由于是传值返回，所以先用d1拷贝构造一个临时对象，再用临时对象拷贝构造d。本来是分两步的，但连续的构造被编译器优化成一步。

请注意：临时对象是右值，const左值引用可以接收右值，故可以匹配拷贝构造函数

(3)传值返回发生移动构造 

我们可以将右值分为两类：

1. 纯右值：内置类型的右值，包括字面常量，表达式结果，函数返回值等等
2. 将亡值：自定义类型的右值，即函数返回值，如它的名字一样，它不会再被使用，马上就会被销毁。

 对于将亡值的拷贝，我们不用照着它的模版重新生成一份，而是直接转移它的资源，这样代价会小很多。因此，我们可以针对这种将亡值专门设计一个构造函数来转移资源，这种构造函数叫移动构造

    //DeepCopy中增加：DeepCopy(DeepCopy&& d){_p = nullptr;std::swap(_p, d._p);std::swap(_n, d._n);cout << "移动构造" << endl;}int main()
{DeepCopy d1(new int[5]{ 1,2,3,4,5 }, 5);d1 = Fun();return 0;
}

编译器会将返回的d1对象特殊处理，将它识别为右值，所以这里用一个右值构造临时对象。右值既虽然可以被const左值引用接收，但右值引用是更合适的，所以会匹配移动构造。同理，临时对象也是个将亡值，所以匹配的是移动构造。两次连续的构造会被编译器优化成一次移动构造。

不仅有移动构造，还有移动赋值:

    //DeepCopy中增加：	DeepCopy& operator=(DeepCopy&& d){if (this != &d){std::swap(_p, d._p);std::swap(_n, d._n);}cout << "移动赋值" << endl;return *this;}
//临时对象的资源不仅被转移走了，还得到了*this不要的资源，析构时会释放掉int main()
{DeepCopy d1(new int[5]{ 1,2,3,4,5 }, 5);d1 = Fun();return 0;
}

3.总结

引用的意义就在于减少拷贝

左值引用:直接减少拷贝:
1.引用传参 2.传引用返回

但有些场景不能传引用返回(函数内的局部对象)，因此还是无法避免深拷贝
右值引用:间接减少拷贝
和const左值引用进行区分，传将亡对象拷贝时匹配移动构造函数，直接转移资源

四.完美转发

(1)属性退化

一个右值引用与右值绑定之后，这个引用的属性是左值。换句话说，右值被右值引用之后属性退化成了左值，从原来的不可修改变为可修改。如果你不想它被修改，可以用const修饰引用，但它仍然是一个左值。

从底层角度来看，实际是右值引用使数据的存储位置发生改变，可以取到数据的地址。

这也能够解释为什么移动构造或移动赋值函数中，能够转移将亡对象资源的原因，因为它的属性退化成了左值，可以被修改。

(2)万能引用

模版参数+&&=万能引用：无论是左值还是右值，无论是const还是非const，都能接收

我们可以用万能引用验证第(1)点的结论 

void fun(int& x)
{cout << "void fun(int& x)左值" << endl;
}void fun(const int& x)
{cout << "void fun(const int& x)const左值" << endl;
}void fun(int&& x)
{cout << "void fun(int&& x)右值" << endl;
}
void fun(const int&& x)
{cout << "void fun(const int&& x)const右值" << endl;
}void PerfectForward(T&& t)//T&& 万能引用
{fun(t);
}int main()
{int a = 10;PerfectForward(a);//左值PerfectForward(10);//右值const int b = 8;PerfectForward(b);//const左值PerfectForward(move(b));//const右值return 0;
}

 

(3)完美转发

如果想要在传递过程中保持对象的左值或右值属性不变，可以使用完美转发std::forward<T>(T是对象的类型)

 将上面的fun函数稍作修改：

void PerfectForward(T&& t)//T&& 万能引用
{fun(forward<T>(t));
}

 五.C++11新增的默认成员函数

C++11新增了两个默认成员函数：移动构造和移动赋值。

如果没有实现移动构造，且拷贝构造，拷贝赋值重载和析构函数都没有实现，那么编译器会生成移动构造函数，对于内置类型逐字节拷贝；对于自定义类型，如果有移动构造则去调用移动构造，没有就退而且其次，调用拷贝构造。

移动赋值的生成规则类似。