右辺値参照は、いくつかの例外を除いて、通常の参照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
};
コンストラクタと代入演算子は、右辺値参照を取るバージョンでオーバーロードされています。右辺値参照により、「左辺値または右辺値で呼び出されているか」という条件で、関数がコンパイル時に（オーバーロード解決を介して）分岐することができます。これにより、リソースをコピーするのではなく移動する、より効率的なコンストラクターと代入演算子を作成できました。
コンパイラーは、コンパイル時に自動的に分岐し（lvalueとrvalueのどちらで呼び出されるかに応じて）、移動コンストラクターと移動割り当て演算子のどちらを呼び出すかを選択します。
要約すると、右辺値参照は移動のセマンティクスを許可します（以下の記事のリンクで説明されている完全な転送）。
実用的で理解しやすい例の1つは、クラステンプレートstd :: unique_ptrです。unique_ptrは、基になるrawポインターの排他的な所有権を維持するため、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らによるRvalue 参照への簡単な紹介です。アル