Что означает T&& (double ampersand) в C++11?

он обозначает ссылку rvalue. Ссылки Rvalue будут привязываться только к временным объектам, если явно не создано иначе. Они используются, чтобы сделать объекты гораздо более эффективными при определенных обстоятельствах и обеспечить средство, известное как perfect forwarding, что значительно упрощает код шаблона.

в C++03 вы не можете различать копию неизменяемого lvalue и 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&);

в C++0x это не случай.

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

рассмотрим реализацию этих конструкторов. В первом случае строка должна выполнить копию для сохранения семантики значения, которая включает новое распределение кучи. Однако, во втором случае, мы заранее знаем, что объект, который был передан в конструктор сразу за разрушение, и он не должен оставаться нетронутым. Мы можем эффективно просто поменять внутренние указатели и не выполнять копирование вообще в этом сценарии, который существенно эффективнее. Семантика перемещения полезна любому классу, который имеет дорогостоящее или запрещенное копирование внутренних ресурсов. Рассмотрим случай std::unique_ptr- теперь, когда наш класс может различать временные и не-временные, мы можем заставить семантику перемещения работать правильно, чтобы unique_ptr не может быть скопирован, но может быть перемещен, что означает, что std::unique_ptr можно законно хранить в стандартных контейнерах, отсортированы, и т. д., Тогда как C++03 это std::auto_ptr не может.

теперь мы рассмотрим другое использование ссылок rvalue-perfect forwarding. Рассмотрим вопрос о привязке ссылки к ссылке.

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

не могу вспомнить, что говорит об этом C++03, но в C++0x результирующий тип при работе со ссылками rvalue имеет решающее значение. Ссылка rvalue на тип T, где T-ссылочный тип, становится ссылкой типа 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&&

рассмотрим простейшую функцию шаблона-min и max. В C++03 вы должны перегрузить все четыре комбинации const и non-const вручную. В C++0x это всего лишь одна перегрузка. Совмещенный с variadic шаблонами, это включает совершенное препровождение.

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

Я оставил вычет типа возврата, потому что я не могу вспомнить, как это делается навскидку, но этот min может принимать любую комбинацию lvalues, rvalues, const lvalues.

на срок T&& при использовании с типом вычета (например, для идеальной пересылки) известен в просторечии как ссылка для пересылки. Термин "универсальная ссылка" был придуман Скоттом Мейерсом в этой статье, но позже был изменен.

это потому, что это может быть либо r-значение, либо l-значение.

пример:

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

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

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

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

больше обсуждения можно найти в ответе для:синтаксис для универсального ссылки

ссылка rvalue-это тип, который ведет себя так же, как обычная ссылка X&, с несколькими исключениями. Самое главное, что когда дело доходит до разрешения перегрузки функций, lvalues предпочитают ссылки lvalue старого стиля, тогда как rvalues предпочитают новые ссылки 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-выражение бытия выражение, которое ссылается на ячейку памяти, и позволяет нам взять адрес этой памяти через & оператор.

почти легче понять сначала, что rvalues выполняют с примером:

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

конструктор и операторы присваивания были перегружены версиями, которые принимают ссылки rvalue. Ссылки Rvalue позволяют функции ветвиться во время компиляции (через разрешение перегрузки) при условии "вызывается ли я на lvalue или rvalue?". это позволило нам создать более эффективный конструктор и операторы назначения выше этого перемещения ресурсы скорее копируют их.

компилятор автоматически ветвится во время компиляции (в зависимости от того, вызывается ли он для lvalue или rvalue), выбирая, следует ли вызывать конструктор перемещения или оператор назначения перемещения.

суммирование: ссылки rvalue позволяют семантику перемещения (и совершенную пересылку, обсуждаемую в ссылке статьи ниже).

один практический простой для понимания пример-это шаблон класса 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);

отличная статья, объясняющая все это и многое другое (например, как rvalues позволяют идеальную пересылку и что это значит) с большим количеством хороших примеров Томас Беккер C++ Rvalue Ссылки Объясняются. Этот пост во многом опирался на его статью.

более короткое введение краткое введение в ссылки Rvalue by Stroutrup, et. Эл!--6-->