C++知识篇--右值引用
一、右值引用
1.1 右值
C++新增了一个新的类型，称为右值引用（R-value reference），记为&&。在介绍右值引用类型之前先介绍什么是左值和右值：
- 左值（lvalue，locator value），右值（rvalue，read value）
- 左值：存储在内存中，有明确存储地址（可取地址）的数据；
- 右值：可以提供数据值的数据（不可取地址）；
区分左值和右值的便捷方式是：可以对表达式取地址（&）就是左值，否则为右值。
所有有名字的变量或对象都是左值，而右值是匿名的。
int a = 520;
int b = 1314;
a = b;一般情况下，位于=前的表达式为左值，位于=后面的表达式为右值。例子中a、b为左值，520、1314为右值。a=b是特殊情况，在这个表达式中a、b都是左值，因为b可以取地址，不能视作右值。
c++11中右值可以分成两种：将亡值（xvalue，expiring value），纯右值（prvalue，pureRvalue）：
- 将亡值：和右值引用相关的表达式，比如T&& 类型函数的返回值、std::move的返回值；
- 纯右值：非引用返回的临时变量、运算表达式产生的临时变量、原始字面值和lambda表达式等；
int value = 520;在上面的语句中，value 是左值，520 是字面量也就是右值。其中 value 可以被引用，但是 520 就不行了，因为字面量都是右值。
1.2 左值引用和右值引用
引用本质是别名，可以通过引用修改变量的值，传参时传引用可以避免拷贝。
1.2.1 左值引用
左值引用大家都很熟悉，能指向左值，不能指向右值的就是左值引用：
int a = 5;
int &ref_a = a; // 左值引用指向左值，编译通过
int &ref_a = 5; // 左值引用指向了右值，会编译失败引用是变量的别名，由于右值没有地址，没法被修改，所以左值引用无法指向右值。
但是，const左值引用是可以指向右值的：
const int &ref_a = 5; // 编译通过const左值引用不会修改指向值，因此可以指向右值。
1.2.2右值引用
右值引用专门为右值而生，可以指向右值，不能指向左值。右值引用的用途，可以修改右值。右值引用就是对一个右值进行引用的类型。因为右值是匿名的，所以我们只能通过引用的方式找到它。无论声明左值引用还是右值引用都必须立即进行初始化，因为引用类型本身并不拥有所绑定对象的内存，只是该对象的一个别名。通过右值引用的声明，该右值又“重获新生”，其生命周期与右值引用类型变量的生命周期一样，只要该变量还活着，该右值临时量将会一直存活下去。
右值引用的使用，参考代码如下：
#include
using namespace std;
int&& value = 520; //里面 520 是纯右值，value 是对字面量 520 这个右值的引用。
class Test
{
public:
Test()
{
cout << "construct: my name is jerry" << endl;
}
Test(const Test& a)
{
cout << "copy construct: my name is tom" << endl;
}
};
Test getObj()
{
return Test();
}
int main()
{
int a1;
int &&a2 = a1; // error 使用左值初始化一个右值引用类型是不合法的。
Test& t = getObj(); // error 右值不能给普通的左值引用赋值。
Test && t = getObj(); // getObj() 返回的临时对象被称之为将亡值，t 是这个将亡值的右值引用。
const Test& t = getObj();//常量左值引用是一个万能引用类型，
//它可以接受左值、右值、常量左值和常量右值。
return 0;
}
1.3对左右值引用本质的讨论
1.3.1 右值引用指向左值
使用std::move
int a = 5; // a是个左值
int &ref_a_left = a; // 左值引用指向左值
int &&ref_a_right = std::move(a); // 通过std::move将左值转化为右值，可以被右值引用指向
cout << a; // 打印结果：5std::move移动不了什么，唯一的功能是把左值强制转化为右值，让右值引用可以指向左值。其实现等同于一个类型转换：static_cast。 所以，单纯的std::move(xxx)不会有性能提升。
同样的，右值引用能指向右值，本质上也是把右值提升为一个左值，并定义一个右值引用通过std::move指向该左值：
int &&ref_a = 5;
ref_a = 6;
等同于以下代码：
int temp = 5;
int &&ref_a = std::move(temp);
ref_a = 6;1.3.2 左值引用、右值引用本身是左值还是右值？
被声明出来的左、右值引用都是左值。 因为被声明出的左右值引用是有地址的，也位于等号左边。仔细看下边代码：
// 形参是个右值引用
void change(int&& right_value) {
right_value = 8;
}
int main() {
int a = 5; // a是个左值
int &ref_a_left = a; // ref_a_left是个左值引用
int &&ref_a_right = std::move(a); // ref_a_right是个右值引用
change(a); // 编译不过，a是左值，change参数要求右值
change(ref_a_left); // 编译不过，左值引用ref_a_left本身也是个左值
change(ref_a_right); // 编译不过，右值引用ref_a_right本身也是个左值
change(std::move(a)); // 编译通过
change(std::move(ref_a_right)); // 编译通过
change(std::move(ref_a_left)); // 编译通过
change(5); // 当然可以直接接右值，编译通过
cout << &a << ' ';
cout << &ref_a_left << ' ';
cout << &ref_a_right;
// 打印这三个左值的地址，都是一样的
}看完后你可能有个问题，std::move会返回一个右值引用int &&，它是左值还是右值呢？ 从表达式int &&ref = std::move(a)来看，右值引用ref指向的必须是右值，所以move返回的int &&是个右值。所以右值引用既可能是左值，又可能是右值吗？ 确实如此：右值引用既可以是左值也可以是右值，如果有名称则为左值，否则是右值。
或者说：作为函数返回值的 && 是右值，直接声明出来的 && 是左值。 这同样也符合第一章对左值，右值的判定方式：其实引用和普通变量是一样的，int &&ref = std::move(a)和 int a = 5没有什么区别，等号左边就是左值，右边就是右值。
从上述的分析中，有以下结论：
- 从性能上讲，左右值引用没有区别，传参使用左右值引用都可以避免拷贝。
- 右值引用可以直接指向右值，也可以通过std::move指向左值；而左值引用只能指向左值(const左值引用也能指向右值)。
- 作为函数形参时，右值引用更灵活。虽然const左值引用也可以做到左右值都接受，但它无法修改，有一定局限性。
二、性能优化
在 C++ 中在进行对象赋值操作的时候，很多情况下会发生对象之间的深拷贝，如果堆内存很大，这个拷贝的代价也就非常大，在某些情况下，如果想要避免对象的深拷贝，就可以使用右值引用进行性能的优化。
再来修改一下上面的实例代码：
#include
using namespace std;
class Test
{
public:
Test() : m_num(new int(100))
{
cout << "construct: my name is jerry" << endl;
}
Test(const Test& a) : m_num(new int(*a.m_num))
{
cout << "copy construct: my name is tom" << endl;
}
~Test()
{
delete m_num;
}
int* m_num;
};
Test getObj()
{
Test t;
return t;
}
int main()
{
Test t = getObj();
cout << "t.m_num: " << *t.m_num << endl;
return 0;
} 输出结果：
construct: my name is jerry
copy construct: my name is tom
t.m_num: 100通过输出的结果可以看到调用 Test t = getObj(); 的时候调用拷贝构造函数对返回的临时对象进行了深拷贝得到了对象 t，在 getObj() 函数中创建的对象虽然进行了内存的申请操作，但是没有使用就释放掉了。如果能够使用临时对象已经申请的资源，既能节省资源，还能节省资源申请和释放的时间，如果要执行这样的操作就需要使用右值引用了，右值引用具有移动语义，移动语义可以将资源（堆、系统对象等）通过浅拷贝从一个对象转移到另一个对象这样就能减少不必要的临时对象的创建、拷贝以及销毁，可以大幅提高 C++ 应用程序的性能。
#include
using namespace std;
class Test
{
public:
Test() : m_num(new int(100))
{
cout << "construct: my name is jerry" << endl;
}
Test(const Test& a) : m_num(new int(*a.m_num))
{
cout << "copy construct: my name is tom" << endl;
}
// 添加移动构造函数
Test(Test&& a) : m_num(a.m_num)
{
a.m_num = nullptr;
cout << "move construct: my name is sunny" << endl;
}
~Test()
{
delete m_num;
cout << "destruct Test class ..." << endl;
}
int* m_num;
};
Test getObj()
{
Test t;
return t;
}
int main()
{
Test t = getObj();
cout << "t.m_num: " << *t.m_num << endl;
return 0;
};
输出结果:
construct: my name is jerry
move construct: my name is sunny
destruct Test class ...
t.m_num: 100
destruct Test class ...
如果不使用移动构造，在执行 Test t = getObj() 的时候也是进行了浅拷贝，但是当临时对象被析构的时候，类成员指针 int* m_num; 指向的内存也就被析构了，对象 t 也就无法访问这块内存地址了。
在测试程序中 getObj() 的返回值就是一个将亡值，也就是说是一个右值，在进行赋值操作的时候如果 = 右边是一个右值，那么移动构造函数就会被调用。移动构造中使用了右值引用，会将临时对象中的堆内存地址的所有权转移给对象t，这块内存被成功续命，因此在t对象中还可以继续使用这块内存。
对于需要动态申请大量资源的类，应该设计移动构造函数，以提高程序效率。需要注意的是，我们一般在提供移动构造函数的同时，也会提供常量左值引用的拷贝构造函数，以保证移动不成还可以使用拷贝构造函数。
todo：构造函数、拷贝构造函数、移动构造函数的含义。。。。
todo：浅拷贝和深拷贝
三、&&的特性
在 C++ 中，并不是所有情况下 && 都代表是一个右值引用，具体的场景体现在模板和自动类型推导中，如果是模板参数需要指定为 T&&，如果是自动类型推导需要指定为 auto &&，在这两种场景下 && 被称作未定的引用类型。另外还有一点需要额外注意 const T&& 表示一个右值引用，不是未定引用类型。
先来看第一个例子，在函数模板中使用 &&:
template
void f(T&& param);
void f1(const T&& param);
f(10); //传入的实参 10 是右值，因此 T&& 表示右值引用
int x = 10;
f(x); //传入的实参是 x 是左值，因此 T&& 表示左值引用
f1(x);//f1(x) 的参数是 const T&& 不是未定引用类型，不需要推导，本身就表示一个右值引用 示例二
int main()
{
int x = 520, y = 1314;
auto&& v1 = x; // auto&& 整形的左值引用
auto&& v2 = 250; //auto&& 表示一个整形的右值引用
decltype(x)&& v3 = y; // error decltype(x)&& 等价于 int&& 是一个右值引用
//不是未定引用类型，y 是一个左值，不能使用左值初始化一个右值引用类型。
cout << "v1: " << v1 << ", v2: " << v2 << endl;
return 0;
};
由于上述代码中存在 T&& 或者 auto&& 这种未定引用类型，当它作为参数时，有可能被一个右值引用初始化，也有可能被一个左值引用初始化，在进行类型推导时右值引用类型（&&）会发生变化，这种变化被称为引用折叠。在 C++11 中引用折叠的规则如下：
- 通过右值推导 T&& 或者 auto&& 得到的是一个右值引用类型
- 通过非右值（右值引用、左值、左值引用、常量右值引用、常量左值引用）推导 T&& 或者 auto&& 得到的是一个左值引用类型
int&& a1 = 5; //a1 为右值引用
auto&& bb = a1; //bb 为左值引用类型
auto&& bb1 = 5; //5 为右值，推导出的 bb1 为右值引用类型
int a2 = 5;//a2为左值
int &a3 = a2;//a3 为左值引用
auto&& cc = a3;//cc 为左值引用类型
auto&& cc1 = a2;//cc1 为左值引用类型
const int& s1 = 100;//s1 为常量左值引用
const int&& s2 = 100;//s2 为常量右值引用
auto&& dd = s1;//dd 为常量左值引用
auto&& ee = s2;//ee 为常量左值引用
const auto&& x = 5;//x 为右值引用，不需要推导，只能通过右值初始化
最后一个示例
#include
using namespace std;
void printValue(int &i)
{
cout << "l-value: " << i << endl;
}
void printValue(int &&i)
{
cout << "r-value: " << i << endl;
}
void forward(int &&k)
{
printValue(k);
}
int main()
{
int i = 520;
printValue(i);
printValue(1314);
forward(250);
return 0;
};
测试代码输出的结果如下:
l-value: 520
r-value: 1314
l-value: 250根据测试代码可以得知，编译器会根据传入的参数的类型（左值还是右值）调用对应的重置函数（printValue），函数 forward () 接收的是一个右值，但是在这个函数中调用函数 printValue () 时，参数 k 变成了一个命名对象，编译器会将其当做左值来处理。
最后总结一下关于 && 的使用：
- 左值和右值是独立于他们的类型的，右值引用类型可能是左值也可能是右值。（移动语义std::move）
- 编译器会将已命名的右值引用视为左值，将未命名的右值引用视为右值。
- auto&&或者函数参数类型自动推导的T&&是一个未定的引用类型，它可能是左值引用也可能是右值引用类型，这取决于初始化的值类型（上面有例子）。
- 通过右值推导 T&& 或者 auto&& 得到的是一个右值引用类型，其余都是左值引用类型。
四、std::move和std::forward
4.1 std::move应用场景
在实际场景中，右值引用和std::move被广泛用于在STL和自定义类中实现移动语义，避免拷贝，从而提升程序性能。 在没有右值引用之前，一个简单的数组类通常实现如下，有构造函数、拷贝构造函数、赋值运算符重载、析构函数等。深拷贝/浅拷贝在此不做讲解。
class Array {
public:
Array(int size) : size_(size) {
data = new int[size_];
}
// 深拷贝构造
Array(const Array& temp_array) {
size_ = temp_array.size_;
data_ = new int[size_];
for (int i = 0; i < size_; i ++) {
data_[i] = temp_array.data_[i];
}
}
// 深拷贝赋值
Array& operator=(const Array& temp_array) {
delete[] data_;
size_ = temp_array.size_;
data_ = new int[size_];
for (int i = 0; i < size_; i ++) {
data_[i] = temp_array.data_[i];
}
}
~Array() {
delete[] data_;
}
public:
int *data_;
int size_;
}; 该类的拷贝构造函数、赋值运算符重载函数已经通过使用左值引用传参来避免一次多余拷贝了，但是内部实现要深拷贝，无法避免。 这时，有人提出一个想法：是不是可以提供一个移动构造函数，把被拷贝者的数据移动过来，被拷贝者后边就不要了，这样就可以避免深拷贝了。右值引用的出现解决了这个问题，在STL的很多容器中，都实现了以右值引用为参数的移动构造函数和移动赋值重载函数，或者其他函数，最常见的如std::vector的push_back和emplace_back。参数为左值引用意味着拷贝，为右值引用意味着移动。
class Array {
public:
......
// 优雅
Array(Array&& temp_array) {
data_ = temp_array.data_;
size_ = temp_array.size_;
// 为防止temp_array析构时delete data，提前置空其data_
temp_array.data_ = nullptr;
}
public:
int *data_;
int size_;
};如何使用：
// 例1：Array用法
int main(){
Array a;
// 做一些操作
.....
// 左值a，用std::move转化为右值
Array b(std::move(a));
}std::move本身只做类型转换，对性能无影响。 我们可以在自己的类中实现移动语义，避免深拷贝，充分利用右值引用和std::move的语言特性。
4.2 完美转发 std::forward
和std::move一样，它的兄弟std::forward也充满了迷惑性，虽然名字含义是转发，但他并不会做转发，同样也是做类型转换.
与move相比，forward更强大，move只能转出来右值，forward都可以。
std::forward
(u)有两个参数：T与 u。 a. 当T为左值引用类型时，u将被转换为T类型的左值；
b. 否则u将被转换为T类型右值。
void change2(int&& ref_r) {
ref_r = 1;
}
void change3(int& ref_l) {
ref_l = 1;
}
// change的入参是右值引用
// 有名字的右值引用是 左值，因此ref_r是左值
void change(int&& ref_r) {
change2(ref_r); // 错误，change2的入参是右值引用，需要接右值，ref_r是左值，编译失败
change2(std::move(ref_r)); // ok，std::move把左值转为右值，编译通过
change2(std::forward(ref_r)); // ok，std::forward的T是右值引用类型(int &&)，符合条件b，因此u(ref_r)会被转换为右值，编译通过
change3(ref_r); // ok，change3的入参是左值引用，需要接左值，ref_r是左值，编译通过
change3(std::forward(ref_r)); // ok，std::forward的T是左值引用类型(int &)，符合条件a，因此u(ref_r)会被转换为左值，编译通过
// 可见，forward可以把值转换为左值或者右值
}
int main() {
int a = 5;
change(std::move(a));
} todo：移动构造函数