右值引用是一种行为，其行为与普通引用X＆相似，但有一些例外。最重要的是，对于函数重载解析，左值更喜欢旧式左值引用，而右值更喜欢新的右值引用：
void foo(X& x); // lvalue reference overload
void foo(X&& x); // rvalue reference overload
X x;
X foobar();
foo(x); // argument is lvalue: calls foo(X&)
foo(foobar()); // argument is rvalue: calls foo(X&&)
那么什么是右值？任何不是左值的东西。左值是表示存储位置的表达式，它允许我们通过＆运算符获取该存储位置的地址。
首先通过一个示例来了解右值可以完成的工作：
#include <cstring>
class Sample {
int *ptr; // large block of memory
int size;
public:
Sample(int sz=0) : ptr{sz != 0 ? new int[sz] : nullptr}, size{sz}
{
if (ptr != nullptr) memset(ptr, 0, sz);
}
// copy constructor that takes lvalue
Sample(const Sample& s) : ptr{s.size != 0 ? new int[s.size] :\
nullptr}, size{s.size}
{
if (ptr != nullptr) memcpy(ptr, s.ptr, s.size);
std::cout << "copy constructor called on lvalue\n";
}
// move constructor that take rvalue
Sample(Sample&& s)
{ // steal s's resources
ptr = s.ptr;
size = s.size;
s.ptr = nullptr; // destructive write
s.size = 0;
cout << "Move constructor called on rvalue." << std::endl;
}
// normal copy assignment operator taking lvalue
Sample& operator=(const Sample& s)
{
if(this != &s) {
delete [] ptr; // free current pointer
size = s.size;
if (size != 0) {
ptr = new int[s.size];
memcpy(ptr, s.ptr, s.size);
} else
ptr = nullptr;
}
cout << "Copy Assignment called on lvalue." << std::endl;
return *this;
}
// overloaded move assignment operator taking rvalue
Sample& operator=(Sample&& lhs)
{
if(this != &s) {
delete [] ptr; //don't let ptr be orphaned
ptr = lhs.ptr; //but now "steal" lhs, don't clone it.
size = lhs.size;
lhs.ptr = nullptr; // lhs's new "stolen" state
lhs.size = 0;
}
cout << "Move Assignment called on rvalue" << std::endl;
return *this;
}
//...snip
};
构造函数和赋值运算符已被带有右值引用的版本重载。右值引用允许函数在编译时（通过重载解析）在条件“是否在左值或右值上调用我？”时分支。这使我们能够在上面创建更有效的构造函数和赋值运算符，从而移动资源而不是复制资源。
编译器在编译时自动分支（取决于是为左值还是右值调用它），选择是否应调用move构造函数或move赋值运算符。
总结：右值引用允许移动语义（以及完美的转发，在下面的文章链接中讨论）。
一个容易理解的实用示例是类模板std :: unique_ptr。由于unique_ptr维护其基础原始指针的专有所有权，因此无法复制unique_ptr。这将违反其专有权的不变性。因此，它们没有副本构造函数。但是他们确实有移动构造函数：
template<class T> class unique_ptr {
//...snip
unique_ptr(unique_ptr&& __u) noexcept; // move constructor
};
std::unique_ptr<int[] pt1{new int[10]};
std::unique_ptr<int[]> ptr2{ptr1};// compile error: no copy ctor.
// So we must first cast ptr1 to an rvalue
std::unique_ptr<int[]> ptr2{std::move(ptr1)};
std::unique_ptr<int[]> TakeOwnershipAndAlter(std::unique_ptr<int[]> param,\
int size)
{
for (auto i = 0; i < size; ++i) {
param[i] += 10;
}
return param; // implicitly calls unique_ptr(unique_ptr&&)
}
// Now use function
unique_ptr<int[]> ptr{new int[10]};
// first cast ptr from lvalue to rvalue
unique_ptr<int[]> new_owner = TakeOwnershipAndAlter(\
static_cast<unique_ptr<int[]>&&>(ptr), 10);
cout << "output:\n";
for(auto i = 0; i< 10; ++i) {
cout << new_owner[i] << ", ";
}
output:
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
static_cast<unique_ptr<int[]>&&>(ptr)通常使用std :: move完成
// first cast ptr from lvalue to rvalue
unique_ptr<int[]> new_owner = TakeOwnershipAndAlter(std::move(ptr),0);
托马斯·贝克尔（Thomas Becker）的C ++ Rvalue References Explained是一篇出色的文章，其中包括很多很好的例子，对所有这些内容（例如，右值如何实现完美的转发以及这意味着什么）进行了解释。这篇文章主要依靠他的文章。
简短的介绍是Stroutrup等人撰写的“ 右值引用简介”。人