rvalue 참조는 몇 가지 예외를 제외하고 일반 참조 X &와 매우 유사하게 작동하는 유형입니다. 가장 중요한 것은 기능 과부하 해결에있어 lvalue는 구식 lvalue 참조를 선호하는 반면 rvalue는 새로운 rvalue 참조를 선호한다는 것입니다.

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&&)

rvalue는 무엇입니까? lvalue가 아닌 모든 것. lvalue는 메모리 위치를 나타내는 표현식이며 & 연산자를 통해 해당 메모리 위치의 주소를 가져올 수 있습니다.

예제를 통해 rvalue가 무엇을 달성하는지 이해하는 것이 가장 쉽습니다.

 #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
};     

생성자와 할당 연산자는 rvalue 참조를 사용하는 버전으로 오버로드되었습니다. Rvalue 참조를 사용하면 “lvalue 또는 rvalue에서 호출되고 있습니까?”라는 조건에서 함수가 컴파일 시간 (과부하 해결을 통해)으로 분기 될 수 있습니다. 이를 통해 리소스를 복사하는 대신보다 효율적인 생성자 및 할당 연산자를 생성 할 수있었습니다.

이동 생성자 또는 이동 할당 연산자를 호출해야하는지 여부를 선택하는 컴파일러는 컴파일 할 때 자동으로 분기합니다 (lvalue 또는 rvalue에 대해 호출되는지 여부에 따라 다름).

요약 : rvalue 참조는 이동 의미론 (그리고 아래 기사 링크에서 설명한 완벽한 전달)을 허용합니다.

이해하기 쉬운 한 가지 예는 클래스 템플릿 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);

좋은 예가 많은 rvalues가 완벽한 전달을 허용하는 방법과 그 의미와 같은 모든 것을 설명하는 훌륭한 기사는 Thomas Becker의 C ++ Rvalue References Explained 입니다. 이 게시물은 그의 기사에 크게 의존했습니다.

짧은 소개는 Stroutrup의 Rvalue References 에 대한 간략한 소개 입니다. 알

답변