Que fait std::move() aux lvalues ​​?

std::move() est un outil puissant en C pour faciliter expédition parfaite. Pourtant, sa mise en œuvre peut faire sourciller au premier coup d’œil. Pour clarifier comment std::move() y parvient, examinons les subtilités de sa mise en œuvre.

Comprendre la fonction « Déplacer »

Nous commencerons par la version simplifiée du modèle de fonction 'move' :

template 
typename remove_reference::type&& move(T&& arg)
{ return static_cast::type&&>(arg); }

Cas 1 : Passage d'une Rvalue

Lorsque std::move() est appelé avec une rvalue (un objet temporaire ou une expression qui s'évalue à une rvalue) , le modèle de déplacement est instancié comme suit :

// move with [T = Object]:
remove_reference

Puisque remove_reference

Object&& move(Object&& arg) { return static_cast

Comme prévu, la fonction convertit simplement son argument rvalue en une référence rvalue.

Cas 2 : Passer une Lvalue

Maintenant, l'intéressant Ce cas se produit lorsque std::move() est invoqué avec une lvalue (une variable nommée ou une expression qui s'évalue à une lvalue).

Object a; // a is lvalue
Object b = std::move(a);

Cette fois, le modèle de déplacement s'instancie en :

// move with [T = Object&]
remove_reference

Encore une fois, remove_reference

Object&& move(Object& && arg) { return static_cast

À première vue, cela semble contre-intuitif puisque nous avons transmis une lvalue. Cependant, C 11 introduit le concept de réduction de référence, qui modifie l'interprétation de la syntaxe de référence :

• Object & & = Object &
• Object & & && = Objet &
• Objet & && & = Objet &
• Objet & && & && = Objet & &&

Selon ces règles, Object& && se comporte effectivement comme Object&, une référence de lvalue ordinaire qui peut se lier à des lvalues.

Par conséquent, la forme finale de la fonction devient :

Object&& move(Object& arg) { return static_cast

En substance, std::move() convertit l'argument lvalue en une référence rvalue, permettant un transfert parfait quel que soit le type d'entrée.