Что означает T && (двойной амперсанд) в C ++ 11?

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

В С++ 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&);

В С++ 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 может быть юридически сохранен в стандартных контейнерах, отсортирован и т.д., тогда как С++ 03 std::auto_ptr не может.

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

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

Не могу вспомнить, что говорит об этом С++ 03, но в С++ 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. В С++ 03 вы должны перегружать все четыре комбинации констант и не константы вручную. В С++ 0x это просто одна перегрузка. В сочетании с вариационными шаблонами это обеспечивает идеальную пересылку.

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 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 является выражением, которое относится к ячейке памяти и позволяет нам адресовать адрес этой ячейки памяти с помощью оператора &.

Сначала легче понять, какие результаты выполняются с помощью примера:

 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 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 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 позволяют совершенную переадресацию и что это означает) с большим количеством хороших примеров - Thomas Becker C++ Rvalue References Explained. Этот пост в значительной степени опирался на его статью.

Более короткое введение - краткое введение в Rvalue References от Stroutrup, et. аль