定义
早期的c给出的定义：左值是一个表达式，可能出现在赋值操作的左边或右边，但右值只能出现在右边。比如：
a * b = 42; // 编译错误， 说明 a * b 不是左值
因为上面的定义实在太模糊，导致左值和右值很难被理解，下面给出的定义，更简单更好理解：
左值（lvalue）是一个表达式，它表示一个可被标识的（变量或对象的）内存位置，并且允许使用&操作符来获取这块内存的地址。如果一个表达式不是左值，那它就被定义为右值。
int i = 42;
i = 43;
int* p = &i; // ok, i 是左值
int& foo();
foo() = 42; // ok, foo() 是左值
int* p1 = &foo(); // ok, foo() 是左值
int foobar();
int j = 0;
j = foobar(); // ok, foobar() 是右值
int* p2 = &foobar(); // 错误，不能获取右值的地址
j = 42; // ok, 42 是右值
左值和右值之间的转换
一般上讲，对象之间的运算，对象是以右值的形式参与的。比如二元运算符 两边的参数以右值传入，加后的返回结果也是右值：
int a = 1; // a 是左值
int b = 2; // b 是左值
int c = a b; // a和b自动转换为右值求和
那些表示数组、函数和非完整类型的左值是不能转换为右值的，因为无法对那些类型进行求值。incomplete types指的是类型定义不完整，只能用指针形式声明的类型，在头文件中经常会使用。
左值引用
c 中可以使用&符定义引用，如果一个左值同时是引用，就称为“左值引用”，如：
std::string s;
std::string& sref = s; //sref为左值引用
非const左值引用不能使用右值对其赋值
std::string& r = std::string(); //错误！std::string（）产生一个临时对象，为右值
假设可以的话，就会遇到一个问题：如何修改右值的值？因为引用是可以后续被赋值的。根据上面的定义，右值连可被获取的内存地址都没有，也就谈不上对其进行赋值。
但const左值引用不一样，因为常量不能被修改，也就不存在上面的问题：
const std::string& r = std::string(); //可以
我们经常使用const左值引用作为函数的参数类型，可以减少不必要的对象复制：
class mystring {
public:
...
mystring &mystring(string& s); //参数类型为左值引用
...
};
int main()
{
mystring s1("xxx"); //错误
mystring s2(string("xxxx")); //同上，右值不能赋值给左值引用
}
把mystring& mystring(string& a);改成mystring& mystring(const string& a);就不会有上面的编译错误。
带cv限定符（cv-qualified）的右值
c 标准中关于左值转右值的讨论，有这样一段话：
类型为t的左值（非函数、非数组类型）可以被转换为右值。如果t不是类（class）类型，转换后的右值的类型将为不带cv限定符的t类型，否则转换后的右值的类型为t。
什么是cv限定符？如果变量声明时类型前带有const或volatile，就说此变量类型具有cv限定符。
在c中，右值永远没有cv限定符，而c 中的类类型的右值可以有cv限定符，看下面代码：
#include
class a {
public:
void foo() const { std::cout << "a::foo() const\n"; }
void foo() { std::cout << "a::foo()\n"; }
};
a bar() { return a(); } //返回临时对象，为右值
const a cbar() { return a(); } //返回带const的右值（带cv限定符）
int main()
{
bar().foo(); // 非const对象调用a::foo()的非const版本
cbar().foo(); // const对象调用a::foo()的const版本
也就是说，如果是类类型，从左值转为右值时，它的cv限定符会被保留。这里就不给出示例代码了。
右值引用（c 11）
右值引用及其相关的move语义是c 11新引入的最强大的特性之一。前文说到，左值（非const）可以被修改（赋值），但右值不能。但c 11引入的右值引用特性，打破了这个限制，允许我们获取右值的引用，并修改之。让我们先看点代码：
定义一个类intvec及其赋值操作符重载函数如下：
class intvec
{
public:
...
intvec& operator=(const intvec& other)
{
log("copy assignment operator");
intvec tmp(other); //构造一个临时对象，因为other为const，不能被修改
std::swap(m_size, tmp.m_size);
std::swap(m_data, tmp.m_data);
//跟临时对象交换值，临时对象晰构时会delete [] m_data
return *this;
}
private:
size_t m_size;
int* m_data; //存放int数组，构造时动态分配
};
代码要点：
代码使用了copy-swap策略，即先分配资源再更改自身状态，这样可以保证当资源分配失败的时候，自身能够维持原先状态，《高效c 》有条规则描述这个主题。所以先根据other拷贝构造一个临时对象tmp， 然后与tmp进行swap，m_data交换给了tmp之后，也会随着tmp的晰构而被释放。
之所以把other声明为const，有两个理由，其一是赋值操作不应该更改other，其二是可以传入一个右值。其实这样的声明随处可见。
假设现有类型为intvec的对象v，用一个新对象给它赋值：
v = intvec(33);
这句代码合法，它构造一个临时对象，为右值，传入到intvec的赋值运算符重载函数中。这个代码是可以工作，而且通常情况下都比较高效。但是如果intvec里包含某些m_handle成员，创建和释放m_handle比较昂贵，那么拷贝构造越少越好。这种情况，我们设想一下，如果v能跟intvec(33)临时对象直接进行内部数据交换，而不需要在重载函数里使用intvec tmp(other);构造一个新对象出来swap，那该有多好！
如你所料，c 11引入的“右值引用”和“move语义”就可以实现这个目标，新的语法很简单，我们重载一个新的赋值操作运算符函数：
intvec& operator=(intvec&& other)
{
log("move assignment operator");
std::swap(m_size, other.m_size);
std::swap(m_data, other.m_data);
return *this;
}
对于v = intvec(33);这种写法就会调用此版本的重载函数（即传入一个右值）。
&&语法声明右值引用，表示一个指向右值的引用，通过这个引用，可以修改右值。
以上就是关于右值引用的一个简单的示例，实际上右值引用是一个复杂的主题，在实际应用中还有很多场景要考虑，更深入的讲解见底部参考链接。