Que signifie T&& (double ampersand) en C++11?

indique une valeur de référence. Les références de valeur ne se lieront qu'aux objets temporaires, sauf si elles sont explicitement générées autrement. Ils sont utilisés pour rendre les objets beaucoup plus efficaces dans certaines circonstances, et pour fournir une facilité connue sous le nom de Perfect forwarding, qui simplifie grandement le code de modèle.

En C++03, vous ne pouvez pas distinguer entre, d'une copie d'un non-mutable lvalue et une 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&);

en C++0x, ce n'est pas cas.

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

envisager la mise en œuvre derrière ces constructeurs. Dans le premier cas, la chaîne doit effectuer une copie pour conserver la sémantique des valeurs, ce qui implique une nouvelle allocation de tas. Cependant, dans le second cas, nous savons à l'avance que l'objet qui a été transmis à notre constructeur doit être immédiatement détruit, et il ne doit pas rester intact. Nous pouvons simplement échanger les pointeurs internes et ne pas effectuer de copie du tout dans ce le scénario, ce qui est nettement plus efficace. La sémantique de déplacement profite à toute classe qui a la copie coûteuse ou interdite de ressources référencées à l'interne. Prenons le cas de std::unique_ptr - maintenant que notre classe peut faire la distinction entre les temporaireset les non-temporels, nous pouvons faire fonctionner correctement la sémantique du mouvement de sorte que le unique_ptr ne peut pas être copié mais peut être déplacé, ce qui signifie que std::unique_ptr peut être stocké légalement dans des conteneurs Standard, triés, etc, tandis que C++03 std::auto_ptr " ne peut pas.

maintenant, nous considérons l'autre utilisation des références de valeur-perfect forwarding. Examinez la question de lier une référence à une référence.

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

ne peut pas se rappeler ce que dit C++03 à ce sujet, mais dans C++0x, le type résultant lors de la gestion des références rvalue est critique. Une référence de valeur à un type T, Où T est un type de référence, devient une référence de 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&&

considèrent le plus simple fonction modèle-min et max. En C++03, vous devez surcharger manuellement les quatre combinaisons de const et non-const. En C++0x, c'est juste une surcharge. Combiné avec des gabarits variadiques, cela permet une transmission parfaite.

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

j'ai abandonné la déduction de type déclaration, parce que je ne peux pas me rappeler comment c'est fait à la main, mais que min peut accepter n'importe quelle combinaison de lvalues, rvalues, const lvalues.

le terme pour T&& lorsqu'il est utilisé avec la déduction de type (comme pour Perfect forwarding) est connu familièrement comme " forwarding reference . Le terme "référence universelle" a été inventé par Scott Meyers dans cet article , mais a été plus tard changé.

, c'est-à-dire qu'il peut s'agir d'une valeur r ou d'une valeur L.

exemples:

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

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

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

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

plus la discussion peut être trouvée dans la réponse pour: syntaxe pour les références universelles

une référence rvalue est un type qui se comporte un peu comme la référence ordinaire X&, avec plusieurs exceptions. Le plus important est qu'en ce qui concerne la résolution de la surcharge de fonction, lvalues préfère les références lvalue à l'ancienne, tandis que rvalues préfère les nouvelles références 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&&)

Qu'est-ce qu'une valeur R? Tout ce qui n'est pas une lvalue. Une lvalue être une expression qui fait référence à un emplacement de mémoire et nous permet de prendre l'adresse de ce l'emplacement de la mémoire via l'opérateur&.

il est presque plus facile de comprendre d'abord ce que rvalues accomplir avec un exemple:

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

le constructeur et les opérateurs d'affectation ont été surchargés avec des versions qui prennent des références de valeur. Les références Rvalue permettent à une fonction de se brancher au moment de la compilation (via une résolution de surcharge) à la condition "suis-je appelé sur une lvalue ou une rvalue?". cela nous a permis de créer plus le constructeur efficace et les opérateurs d'affectation ci-dessus qui déplacent les ressources plutôt les copier.

le compilateur se ramifie automatiquement au moment de la compilation (selon qu'il est invoqué pour une valeur L ou une valeur R) En choisissant si le constructeur de mouvements ou l'opérateur d'affectation de mouvements doit être appelé.

en résumé: les références rvalue autoriser la sémantique de déplacement (et de transfert parfait, discuté dans l'article en lien ci-dessous).

un exemple pratique facile à comprendre est le modèle de classe std::unique_ptr . Puisqu'un unique_ptr conserve la propriété exclusive de son pointeur brut sous-jacent, unique_ptr ne peut pas être copié. Cela violerait leur invariant de propriété exclusive. Ils n'ont pas de copie des constructeurs. Mais ils ont des constructeurs move:

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) est habituellement fait en utilisant std:: move

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

un excellent article expliquant tout cela et plus encore (comme la façon dont les valeurs de R permettent l'expédition parfaite et ce que cela signifie) avec beaucoup de bons exemples est de Thomas Becker C++ Rvalue les références expliquées . Ce post est fortement appuyée sur son article.

une brève introduction est une brève Introduction aux références de valeur par Stroutrup, et. al