深入解读C++中的右值引用
右值引用（及其支持的Move语意和完美转发）是C++0x将要加入的最重大语言特性之一，这点从该特性的提案在C++-StateoftheEvolution列表上高居榜首也可以看得出来。
从实践角度讲，它能够完美解决C++中长久以来为人所诟病的临时对象效率问题。从语言本身讲，它健全了C++中的引用类型在左值右值方面的缺陷。从库设计者的角度讲，它给库设计者又带来了一把利器。从库使用者的角度讲，不动一兵一卒便可以获得“免费的”效率提升…
在标准C++语言中，临时量（术语为右值，因其出现在赋值表达式的右边）可以被传给函数，但只能被接受为const&类型。这样函数便无法区分传给const&的是真实的右值还是常规变量。而且，由于类型为const&，函数也无法改变所传对象的值。C++0x将增加一种名为右值引用的新的引用类型，记作typename&&。这种类型可以被接受为非const值，从而允许改变其值。这种改变将允许某些对象创建转移语义。比如，一个std::vector，就其内部实现而言，是一个C式数组的封装。如果需要创建vector临时量或者从函数中返回vector，那就只能通过创建一个新的vector并拷贝所有存于右值中的数据来存储数据。之后这个临时的vector则会被销毁，同时删除其包含的数据。有了右值引用，一个参数为指向某个vector的右值引用的std::vector的转移构造器就能够简单地将该右值中C式数组的指针复制到新的vector，然后将该右值清空。这里没有数组拷贝，并且销毁被清空的右值也不会销毁保存数据的内存。返回vector的函数现在只需要返回一个std::vector<>&&。如果vector没有转移构造器，那么结果会像以前一样：用std::vector<>&参数调用它的拷贝构造器。如果vector确实具有转移构造器，那么转移构造器就会被调用，从而避免大量的内存分配。
一.定义
通常意义上，在C++中，可取地址，有名字的即为左值。不可取地址，没有名字的为右值。右值主要包括字面量，函数返回的临时变量值，表达式临时值等。右值引用即为对右值进行引用的类型，在C++98中的引用称为左值引用。
如有以下类和函数:
classA
{
private:
int*_p;
};
AReturnValue()
{
returnA();
}
ReturnValue()的返回值即为右值，它是一个不具名的临时变量。在C++98中，只有常量左值引用才能引用这个值。
A&a=ReturnValue();//error:non-constlvaluereferencetotype'A'cannotbindtoatemporaryoftype'A' constA&a2=ReturnValue();//ok通过常量左值引用，可以延长ReturnValue()返回值的生命周期，但是不能修改它。C++11的右值引用出场了：
A&&a3=ReturnValue();右值引用通过”&&”来声明，a3引用了ReturnValue()的返回值，延长了它的生命周期，并且可以对该临时值进行修改。
二.移动语义
右值引用可以引用并修改右值，但是通常情况下，修改一个临时值是没有意义的。然而在对临时值进行拷贝时，我们可以通过右值引用来将临时值内部的资源移为己用，从而避免了资源的拷贝：
#include<iostream>
classA
{
public:
A(inta)
:_p(newint(a))
{
}
//移动构造函数移动语义
A(A&&rhs)
:_p(rhs._p)
{
//将临时值资源置空避免多次释放现在资源的归属权已经转移
rhs._p=nullptr;
std::cout<<"MoveConstructor"<<std::endl;
}
//拷贝构造函数复制语义
A(constA&rhs)
:_p(newint(*rhs._p))
{
std::cout<<"CopyConstructor"<<std::endl;
}
private:
int*_p;
};
AReturnValue(){returnA(5);}
intmain()
{
Aa=ReturnValue();
return0;
}
运行该代码，发现MoveConstructor被调用(在g++中会对返回值进行优化，不会有任何输出。可以通过-fno-elide-constructors关闭这个选项)。在用右值构造对象时，编译器会调用A(A&&rhs)形式的移动构造函数，在移动构造函数中，你可以实现自己的移动语义，这里将临时对象中_p指向内存直接移为己用，避免了资源拷贝。当资源非常大或构造非常耗时时，效率提升将非常明显。如果A没有定义移动构造函数，那么像在C++98中那样，将调用拷贝构造函数，执行拷贝语义。移动不成，还可以拷贝。
std::move：
C++11提供一个函数std::move()来将一个左值强制转化为右值：
Aa1(5); Aa2=std::move(a1);上面的代码在构造a2时将会调用移动构造函数，并且a1的_p会被置空，因为资源已经被移动了。而a1的生命周期和作用域并没有变，仍然要等到main函数结束后再析构，因此之后对a1的_p的访问将导致运行错误。
std::move乍一看没什么用。它主要用在两个地方：
- 帮助更好地实现移动语义
- 实现完美转发(下面会提到)
考虑如下代码：
classB
{
public:
B(B&&rhs)
:_pb(rhs._pb)
{
//howcanimoverhs._atothis->_a?
rhs._pb=nullptr;
}
private:
A_a;
int*pb;
}
对于B的移动构造函数来说，由于rhs是右值，即将被释放，因此我们不只希望将_pb的资源移动过来，还希望利用A类的移动构造函数，将A的资源也执行移动语义。然而问题出在如果我们直接在初始化列表中使用：_a(rhs._a)将调用A的拷贝构造函数。因为参数rhs._a此时是一个具名值，并且可以取址。实际上，B的移动构造函数的参数rhs也是一个左值，因为它也具名，并且可取址。这是在C++11右值引用中让人很迷惑的一点：可以接受右值的右值引用本身却是个左值这一点在后面的完美转发还会提到。现在我们可以用std::move来将rhs._a转换为右值：_a(std::move(rhs._a))，这样将调用A的移动构造。实现移动语义。当然这里我们确信rhs._a之后不会在使用，因为rhs即将被释放。
三.完美转发
如果仅仅为了实现移动语义，右值引用是没有必要被提出来的，因为我们在调用函数时，可以通过传引用的方式来避免临时值的生成，尽管代码不是那么直观，但效率比使用右值引用只高不低。
右值引用的另一个作用是完美转发，完美转发出现在泛型编程中，将模板函数参数传递给该函数调用的下一个模板函数。如：
template<typenameT>
voidForward(Tt)
{
Do(t);
}
上面的代码中，我们希望Forward函数将传入参数类型原封不动地传递给Do函数，即Forward函数接收的左值，则Do接收到左值，Forward接收到右值，Do也将得到右值。上面的代码能够正确转发参数，但是是不完美的，因为Forward接收参数时执行了一次拷贝。考虑到避免拷贝，我们可以传递引用，形如Forward(T&t)，但是这种形式的Forward并不能接收右值作为参数，如Forward(5)。因为非常量左值不能绑定到右值。考虑常量左值引用：Forward(constT&t)，这种形式的Forward能够接收任何类型(常量左值引用是万能引用)，但是由于加上了常量修饰符，因此无法正确转发非常量左值引用：
voidDo(int&i)
{
//dosomething...
}
template<typenameT>
voidForward(constT&t)
{
Do(t);
}
intmain()
{
inta=8;
Forward(a);//error.'voidDo(int&)':cannotconvertargument1from'constint'to'int&'
return0;
}
基于这种情况，我们可以对Forward的参数进行const重载，即可正确传递左值引用。但是当Do函数参数为右值引用时，Forward(5)仍然不能正确传递，因为Forward中的参数都是左值引用。
下面介绍在C++11中的解决方案。
PS：引用折叠
C++11引入了引用折叠规则，结合右值引用来解决完美转发问题：
typedefconstintT; typedefT&TR; TR&v=1;//在C++11中v的实际类型为constint&如上代码中，发生了引用折叠，将TR展开，得到T&&v=1(注意这里不是右值引用)。这里的T&+&被折叠为T&。更为详细的，根据TR的类型定义，以及v的声明，发生的折叠规则如下：
T&+&=T& T&+&&=T& T&&+&=T& T&&+&&=T&&上面的规则被简化为：只要出现左值引用，规则总是优先折叠为左值引用。仅当出现两个右值引用才会折叠为右值引用。
再谈转发
那么上面的引用折叠规则，对完美转发有什么用呢？我们注意到，对于T&&类型，它和左值引用折叠为左值引用，和右值引用折叠为右值引用。基于这种特性，我们可以用T&&作为我们的转发函数模板参数：
template<typenameT>
voidForward(T&&t)
{
Do(static_cast<T&&>(t));
}
这样，无论Forward接收到的是左值，右值，常量，非常量，t都能保持为其正确类型。当传入左值引用X&时：
voidForward(X&&&t)
{
Do(static_cast<X&&&>(t));
}
折叠后：
voidForward(X&t)
{
Do(static_cast<X&>(t));
}
这里的static_cast看起来似乎是没有必要，而它实际上是为右值引用准备的：
voidForward(X&&&&t)
{
Do(static_cast<X&&&&>(t));
}
折叠后：
voidForward(X&&t)
{
Do(static_cast<X&&>(t));
}
前面提到过，可以接收右值的右值引用本身却是个左值，因为它具名并且可以取值。因此在Forward(X&&t)中，参数t已经是一个左值了，此时我们需要将其转换为它本身传入的类型，即为右值。由于static_cast中引用折叠的存在，我们总能还原参数本来的类型。在C++11中，static_cast<T&&>(t)可以通过std::forward<T>(t)来替代，std::forward是C++11用于实现完美转发的一个函数，它和std::move一样，都通过static_cast来实现。我们的Forward函数最终变成了：
template<typenameT>
voidForward(T&&t)
{
Do(std::forward<T>(t));
}
可以通过如下代码来测试：
#include<iostream>
usingnamespacestd;
voidDo(int&i){cout<<"左值引用"<<endl;}
voidDo(int&&i){cout<<"右值引用"<<endl;}
voidDo(constint&i){cout<<"常量左值引用"<<endl;}
voidDo(constint&&i){cout<<"常量右值引用"<<endl;}
template<typenameT>
voidPerfectForward(T&&t){Do(forward<T>(t));}
intmain()
{
inta;
constintb;
PerfectForward(a);//左值引用
PerfectForward(move(a));//右值引用
PerfectForward(b);//常量左值引用
PerfectForward(move(b));//常量右值引用
return0;
}
四.附注
左值和左值引用，右值和右值引用都是同一个东西，引用不是一个新的类型，仅仅是一个别名。这一点对于理解模板推导很重要。对于以下两个函数
template<typenameT>
voidFun(Tt)
{
//dosomething...
}
template<typenameT>
voidFun(T&t)
{
//dootherthing...
}
Fun(Tt)和Fun(T&t)他们都能接受左值(引用)，它们的区别在于对参数作不同的语义，前者执行拷贝语义，后者只是取个新的别名。因此调用Fun(a)编译器会报错，因为它不知道你要对a执行何种语义。另外，对于Fun(Tt)来说，由于它执行拷贝语义，因此它还能接受右值。因此调用Fun(5)不会报错，因为左值引用无法引用到右值，因此只有Fun(Tt)能执行拷贝。
最后，附上VS中std::move和std::forward的源码:
//move
template<class_Ty>
inlinetypenameremove_reference<_Ty>::type&&move(_Ty&&_Arg)_NOEXCEPT
{
return((typenameremove_reference<_Ty>::type&&)_Arg);
}
//forward
template<class_Ty>
inline_Ty&&forward(typenameremove_reference<_Ty>::type&_Arg)
{//forwardanlvalue
return(static_cast<_Ty&&>(_Arg));
}
template<class_Ty>
inline_Ty&&forward(typenameremove_reference<_Ty>::type&&_Arg)_NOEXCEPT
{//forwardanything
static_assert(!is_lvalue_reference<_Ty>::value,"badforwardcall");
return(static_cast<_Ty&&>(_Arg));
}