Co oznacza T& & (double ampersand) w C++11?

Oznacza referencję rvalue. Odniesienia Rvalue będą wiązać się tylko z obiektami tymczasowymi, chyba że jawnie wygenerowano inaczej. Są one używane, aby obiekty były znacznie bardziej wydajne w pewnych okolicznościach i aby zapewnić obiekt znany jako doskonałe przekazywanie, co znacznie upraszcza kod szablonu.

W C++03 nie można odróżnić kopii nie-mutowalnego lvalue od rvalue.

std::string s;
std::string another(s);           // calls std::string(const std::string&);
std::string more(std::string(s)); // calls std::string(const std::string&);

W C++0x tak nie jest.

std::string s;
std::string another(s);           // calls std::string(const std::string&);
std::string more(std::string(s)); // calls std::string(std::string&&);

Rozważmy realizacja tych konstruktorów. W pierwszym przypadku łańcuch znaków musi wykonać kopię, aby zachować semantykę wartości, co wiąże się z nową alokacją sterty. Jednak w drugim przypadku wiemy z góry, że obiekt, który został przekazany naszemu konstruktorowi, jest natychmiast gotowy do zniszczenia i nie musi pozostać nietknięty. Możemy skutecznie po prostu zamienić wewnętrzne wskaźniki i nie wykonywać żadnego kopiowania w tym scenariuszu, co jest znacznie bardziej efektywne. Semantyka ruchu korzystaj z każdej klasy, która ma kosztowne lub zabronione kopiowanie zasobów odwołanych wewnętrznie. Rozważmy przypadek std::unique_ptr - Teraz, gdy nasza klasa może rozróżniać tymczasowe i nie-tymczasowe, możemy sprawić, że semantyka move będzie działać poprawnie tak, że unique_ptr nie może być kopiowana, ale może być przenoszona, co oznacza, że std::unique_ptr może być legalnie przechowywana w standardowych kontenerach, sortowana itp., Podczas Gdy std::auto_ptr C++03 nie może.

Teraz rozważamy inne użycie referencji rvalue-perfect forwarding. Rozważmy kwestię wiązania odniesienia do odniesienia.

std::string s;
std::string& ref = s;
(std::string&)& anotherref = ref; // usually expressed via template

Nie pamiętam, co mówi o tym C++03, ale w C++0x, wynikowy typ w przypadku referencji rvalue jest krytyczny. Rvalue reference to a type T, where t is a reference type, becomes a reference of type T.

(std::string&)&& ref // ref is std::string&
(const std::string&)&& ref // ref is const std::string&
(std::string&&)&& ref // ref is std::string&&
(const std::string&&)&& ref // ref is const std::string&&

Rozważmy najprostszą funkcję szablonu-min i max. W C++03 trzeba przeciążać wszystkie cztery kombinacje const i non-const ręcznie. W C++0x to tylko jedno przeciążenie. W połączeniu z różnymi szablonami umożliwia to doskonałe przekazywanie.

template<typename A, typename B> auto min(A&& aref, B&& bref) {
    // for example, if you pass a const std::string& as first argument,
    // then A becomes const std::string& and by extension, aref becomes
    // const std::string&, completely maintaining it's type information.
    if (std::forward<A>(aref) < std::forward<B>(bref))
        return std::forward<A>(aref);
    else
        return std::forward<B>(bref);
}

Opuściłem dedukcję typu zwrotu, ponieważ nie pamiętam, jak to się robi od ręki, ale ten min może zaakceptować dowolną kombinację lvalues, rvalues, const lvalues.

Określenie na T&& w przypadku użycia z dedukcją typu (np. dla doskonałego przekierowania) jest potocznie znany jako odniesienie do przekierowania . Termin "universal reference" został wymyślony przez Scotta Meyersa w tym artykule, ale został później zmieniony.

To dlatego, że może być albo r-wartość lub L-wartość.

Przykłady to:

// template
template<class T> foo(T&& t) { ... }

// auto
auto&& t = ...;

// typedef
typedef ... T;
T&& t = ...;

// decltype
decltype(...)&& t = ...;

Więcej dyskusji można znaleźć w odpowiedzi na: składnia dla odniesień uniwersalnych

Referencja rvalue jest typem, który zachowuje się podobnie do zwykłego referencji X&, z kilkoma wyjątkami. Najważniejsze jest to, że jeśli chodzi o rozdzielczość przeciążenia funkcji, lvalue preferuje odniesienia w starym stylu lvalue, podczas gdy rvalue preferuje nowe odniesienia 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&&)

Więc co to jest rvalue? Wszystko, co nie jest lvalue. Istota lvalue wyrażenie, które odnosi się do lokalizacji pamięci i pozwala nam pobrać adres tej lokalizacji pamięci za pomocą operatora&.

Prawie łatwiej jest najpierw zrozumieć, co wartości R osiągają na przykładzie:

 class Sample {
  int *ptr; // large block of memory
  int size;
 public:
  Sample(int sz=0) : ptr{sz != 0 ? new int[sz] : nullptr}, size{sz} 
  {}
  // copy constructor that takes lvalue 
  Sample(const Sample& s) : ptr{s.size != 0 ? new int[s.size] :\
      nullptr}, size{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
      ptr = new int[s.size]; 
      size = s.size; 
    }
    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
};     

Konstruktor i operatory przypisań zostały przeciążone wersjami, które przyjmują odwołania do rvalue. Referencje Rvalue pozwalają funkcji rozgałęziać się w czasie kompilacji (poprzez rozdzielczość przeciążenia) pod warunkiem "Am I being called on an lvalue or an rvalue?". pozwoliło nam to stworzyć bardziej wydajny konstruktor i operatory przypisań powyżej, które przenoszą zasoby, a raczej kopiują oni.

Kompilator automatycznie rozgałęzia się w czasie kompilacji (w zależności od tego, czy jest wywoływany dla lvalue czy rvalue) wybierając, czy konstruktor move lub operator przypisania move mają być wywoływane.

Podsumowując: referencje rvalue umożliwiają semantykę przenoszenia (oraz doskonałe przekazywanie, omówione w artykule link poniżej).

Praktycznym, łatwym do zrozumienia przykładem jest szablon klasy std:: unique_ptr. Ponieważ unique_ptr utrzymuje wyłączna własność jego podstawowego surowego wskaźnika, unique_ptr nie może być kopiowana. To naruszyłoby ich niezmienność wyłącznej własności. Nie mają więc konstruktorów kopiujących. Ale mają konstruktory ruchu:

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) zwykle odbywa się za pomocą std:: move

// first cast ptr from lvalue to rvalue
unique_ptr<int[]> new_owner = TakeOwnershipAndAlter(std::move(ptr),0);

Doskonały artykuł wyjaśniający to wszystko i więcej (jak np. jak wartości R umożliwiają doskonałe przekazywanie i co to oznacza) z wieloma dobrymi przykładami jest Thomas Becker C++ rvalue reference Wyjaśnione . Ten post opierał się w dużej mierze na jego artykule.

Krótszym wstępem jest Krótkie wprowadzenie do referencji Rvalue autorstwa Stroutrup, et. al