这个问题牵涉到得首先是左值(L-value)和右值(R-value)的概念;
1. 我查资料的时候发现很多地方都引用一句话:"通俗的讲，左值就是能够出现在赋值符号左面的东西，而右值就是那些可以出现在赋值符号右面的东西了。"我觉得这句话在刚开始理解的时候是什么用都没有的一句废话.因为我们都不知道哪些东西应该放在赋值符号的左边,哪些东西又应该放在赋值符号的右边这样说是没有意义的.
2.接着我找到个比较靠谱的定义:左值是指具有对应的可由用户访问的存储单元，并且能由用户改变其值的量。如一个变量就是一个左值，因为它对应着一个存储单元，并可由编程者通过变量名访问和改变其值。
(下面的第三点是c++primer中的)
3.变量和文字常量都有存储区，并且有相关的类型。区别在于变量是可寻址的（addressable）对于每一个变量都有两个值与其相联：
1).它的数据值，存储在某个内存地址中。有时这个值也被称为对象的右值（rvalue,读做are-value）.我们也可认为右值的意思是被读取的值（read value）。 文字常量和变量都可 被用作右值。
2).它的地址值——即存储数据值的那块内存的地址。它有时被称为变量的左值（lvalue，读作ell-value）。我们也可认为左值的意思是位置值location value文字常量不能被用作左值
有些变量既可以当左值右可以当右值。
-
左值(Lvalue) →→ Location
表示内存中可以寻址，可以给它赋值(const类型的变量例外)
-
右值Rvalue) →→ Read
表示可以知道它的值（例如常数）
一个典型的例子
a++ ： 先使用a的值，再给a加1，作为 右值
// a++的实现
int temp = a;
a = a + 1;
return temp;
- ++a ： 先加再用，作为 左值
a = a + 1;
return a;
左值符号 &
右值符号 &&
在C++中，临时对象不能作为左值，但是可以作为常量引用，
const &
。
C++ 11中的std::move可将左值引用转化成右值引用。
左值和右值
左值：指表达式结束后依然存在的持久对象，可以取地址，具名变量或对象
右值：表达式结束后就不再存在的临时对象，不可以取地址，没有名字。
比如
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; // 常量左值引用 绑定到 右值，编译通过
右值引用通常不能绑定到任何的左值，要想绑定一个左值到右值引用，通常需要std::move()将左值强制转换为右值。比如：
int a;
int &&r1 = a; // 编译失败
int &&r2 = std::move(a); // 编译通过
右值引用特点
右值引用独立于左值和右值。意思是右值引用类型的变量可能是左值也可能是右值。比如：
int&& val1 = x;
var1类型为右值引用，但var1本身是左值，因为具名变量都是左值。
T&& 并不一定表示右值，它绑定的类型是未定的，既可能是左值又可能是右值。
template<typename T>
void f(T&& param){}
f(10); //param是右值
int x = 10;
f(x); //param是左值
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);
};
上面的例子中，param是universal references，rhs 是 Test&& 右值引用，因为模版函数 func 发生了类型推断，而 Test&& 并没有发生类型推导，因为 Test&& 是确定的类型了.
再看一个例子：
template<typename T>
void func(const T&& param);
上面的例子中param不是 universal references，它其实是一个右值引用。universal references 仅仅在 T&& 下发生，任何一点附加条件都会使之失效，所以上面被 const 修饰之后就成了右值引用了。
引用折叠规则
经过类型推导的 T&& 类型，相比右值引用(&&)会发生类型变化，这种变化被称为引用折叠或崩塌。规则：
- 所有的右值引用叠加到右值引用上仍然还是一个右值引用；
- 所有的其他引用类型之间的叠加都将变成左值引用。
总之是，所有的右值引用叠加到右值引用上仍然是一个右值引用，其他引用折叠都是左值引用。
T& &、T& &&和T&& & 都折叠成类型 T&
T&& &&折叠成 T&&
右值函数模版参数类型推导
template<typename T>
void foo(T&&);
1. 当传给foo函数的参数是一个左值时，例如：
int i = 29;
foo(i);//i为左值引用
此时，T的类型为int的左值引用：int&，参数类型为int& &&，（即T&&），结合上面的引用折叠规则，最终参数的类型为int的左值引用：int&。
2. 当传给foo函数的参数是一个右值时，例如：
foo(29);
此时，T的类型为int，参数类型为int&&，（即T&&）。
还在理解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;
}
输出结果：
Forwaid函数收到一个右值，在转发给PrintfValue时又变成了左值，在Forward中调用PrintfValue时，右值i变成了一个命名的对象，编译器会把它当作左值处理。
左值引用, 即&i, 是一种对象类型的引用; 右值引用, 即&&i, 是一种对象值的引用;
std::move()可以把左值引用, 转换为右值引用;
左值引用是固定的引用, 右值引用是易变的引用, 只能引用字面值(literals)或临时对象(temporary object);
右值引用主要应用在移动构造器(move constructor)和移动-赋值操作符(move-assignment operator)上面;
代码如下
/*
* cppprimer.cpp
*
* Created on: 2013.11.7
* Author: Caroline
*/
#include <iostream>
#include <utility>
int main (void) {
int i = 42;
int &lr = i;
int &&rr = i*42;
const int &lr1 = i*42;
int &&rr1 = 42;
int &&rr2 = std::move(lr);
std::cout << "i = " << i << std::endl;
std::cout << "lr = " << lr << std::endl;
std::cout << "rr = " << rr << std::endl;
std::cout << "lr1 = " << lr1 <<std::endl;
std::cout << "rr1 = " << rr1 << std::endl;
std::cout << "rr2 = " << rr2 << std::endl;
}
![C++入门基础知识[2]——运算符C++入门基础知识[2]—运算符[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)