[C++11]左值、右值、左值引用、右值引用小结

左值和右值
左值：指表达式结束后依然存在的持久对象，可以取地址，具名变量或对象
右值：表达式结束后就不再存在的临时对象，不可以取地址，没有名字。
比如 int a = b + c;，a 就是一个左值，可以对a取地址，而b+c 就是一个右值，对表达式b+c 取地址会报错。C++11中右值又由两个概念组成：将亡值和纯右值。

纯右值和将亡值
在C++98中，右值是纯右值，纯右值指的是临时变量值、不跟对象关联的字面量值。包括非引用的函数返回值、表达式等，比如 2、‘ch’、int func()等。将亡值是C++11新增的、与右值引用相关的表达式。

纯右值：非引用返回的临时变量( int func(void) )、运算表达式产生的临时变量(b+c)、原始字面量(2)、lambda表达式等。
将亡值：将要被移动的对象、T&&函数返回值、std::move返回值和转换为T&&的类型的转换函数的返回值。
将亡值可以理解为通过“盗取”其他变量内存空间的方式获取到的值。在确保其他变量不再被使用、或即将被销毁时，通过“盗取”的方式可以避免内存空间的释放和分配，能够延长变量值的生命期。

右值引用和左值引用
介绍
右值引用就是对一个右值进行引用的类型，标记为 T&&。因为右值不具名，是以引用的形式找到它，用引用来表示，右值引用也是引用的引用（我目前是这么想的）。

左值引用就是对一个左值进行引用的类型。

引用本身不拥有所绑定对象的内存，只是该对象的一个别名，左值引用就是有名变量的别名，右值引用是不具名变量的别名。因此无论左值引用还是右值引用都必须立即进行初始化。

通过右值引用，这个将亡的右值又“重获新生”，它的生命周期与右值引用类型变量的生命周期一样，只要这个右值引用类型的变量还活着，那么这个右值临时量就会一直活着，这是一重要特性，可利用这一点会一些性能优化，避免临时对象的拷贝构造和析构。

左值引用包括常量左值引用和非常量左值引用。非常量左值引用只能接受左值，不能接受右值；常量左值引用是一个“万能”的引用类型，可以接受左值（常量左值、非常量左值）、右值。不过常量左值所引用的右值在它的“余生”中只能是只读的。

int &a = 2; // 非常量左值引用 绑定到 右值，编译失败

int b = 2; // b 是非常量左值
const int &c = b; // 常量左值引用 绑定到 非常量左值，编译通过

const int d = 2; // d 是常量左值
const int &e = d; // 常量左值引用 绑定到 常量左值，编译通过
const int &f =2; // 常量左值引用 绑定到 右值，编译通过
1
2
3
4
5
6
7
8
右值引用通常不能绑定到任何的左值，要想绑定一个左值到右值引用，通常需要std::move()将左值强制转换为右值。比如：

int a;
int &&r1 = a; // 编译失败
int &&r2 = std::move(a); // 编译通过
1
2
3
右值引用特点
右值引用独立于左值和右值。意思是右值引用类型的变量可能是左值也可能是右值。比如：

int&& val1 = x;
1
var1类型为右值引用，但var1本身是左值，因为具名变量都是左值。

T&& 并不一定表示右值，它绑定的类型是未定的，既可能是左值又可能是右值。

template<typename T>
void f(T&& param){}

f(10); //param是右值

int x = 10;
f(x); //param是左值
1
2
3
4
5
6
7
T&& param，表示param实际上是一个未定的引用类型，称为universal references，可以认为它是一种未定的引用类型，它必须被初始化，它是左值还是右值引用取决于它的初始化，如果&&被一个左值初始化，它就是一个左值；如果它被一个右值初始化，它就是一个右值。
上面例子，当参数为右值10的时候，根据universal references的特点，param 被一个右值初始化，那么 param 就是右值；当参数为左值 x 时，param 被一个左值引用初始化，那么 param 就是一个左值。

只有发生自动类型推断时（如函数模板的类型自动推导，或auto关键字），T&& 才是一个universal references。比如

template<typename T>
void func(T&& param) //T需要推导，&&是一个universal references

template<typename T>
class Test {
Test(Test&& rhs);
};
1
2
3
4
5
6
7
上面的例子中，param是universal references，rhs 是 Test&& 右值引用，因为模版函数 func 发生了类型推断，而 Test&& 并没有发生类型推导，因为 Test&& 是确定的类型了.

再看一个例子：

template<typename T>
void func(const T&& param);
1
2
上面的例子中param不是 universal references，它其实是一个右值引用。universal references 仅仅在 T&& 下发生，任何一点附加条件都会使之失效，所以上面被 const 修饰之后就成了右值引用了。

引用折叠规则
经过类型推导的 T&& 类型，相比右值引用(&&)会发生类型变化，这种变化被称为引用折叠或崩塌。规则：

所有的右值引用叠加到右值引用上仍然还是一个右值引用；
所有的其他引用类型之间的叠加都将变成左值引用。
总之是，所有的右值引用叠加到右值引用上仍然是一个右值引用，其他引用折叠都是左值引用。

T& &、T& &&和T&& & 都折叠成类型 T&
T&& &&折叠成 T&&

右值函数模版参数类型推导
template<typename T>
void foo(T&&);
1
2
-
1
1. 当传给foo函数的参数是一个左值时，例如：

int i = 29;
foo(i);//i为左值引用
1
2
此时，T的类型为int的左值引用：int&，参数类型为int& &&，（即T&&），结合上面的引用折叠规则，最终参数的类型为int的左值引用：int&。
1
2. 当传给foo函数的参数是一个右值时，例如：

foo(29);
1
此时，T的类型为int，参数类型为int&&，（即T&&）。
1
还在理解ing，感觉好复杂，也不会用呢，先到这。

还有一点，忘了加上。
编译器会把已命名的右值引用视为左值，而将未命名的右值引用视为右值。

#include <iostream>
#include <string>
#include <stack>
#include <vector>
#include <algorithm>
#include <cstdio>

using namespace std;

void PrintValue(int & i)
{
cout << "lvalue : " << i << endl;
}

void PrintValue(int&& i)
{
cout << "rvalue : " << i << endl;
}

void Forward(int&& i)
{
PrintValue(i);
}

int main()
{
int i = 0;
PrintValue(i);
PrintValue(1);
Forward(2);

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
输出结果：

Forwaid函数收到一个右值，在转发给PrintfValue时又变成了左值，在Forward中调用PrintfValue时，右值i变成了一个命名的对象，编译器会把它当作左值处理。
————————————————
版权声明：本文为CSDN博主「Tanswer_」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Tanswer_/article/details/77005674