Maison > développement back-end > C++ > Comment std::move() gère-t-il les valeurs L en C ?

Comment std::move() gère-t-il les valeurs L en C ?

Mary-Kate Olsen
Libérer: 2024-11-14 14:46:02
original
415 Les gens l'ont consulté

How Does std::move() Handle Lvalues in C  ?

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 « Move »

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

template <typename T>
typename remove_reference<T>::type&& move(T&& arg)
{ return static_cast<typename remove_reference<T>::type&&>(arg); }
Copier après la connexion

Cas 1 : Passer 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<Object>::type&& move(Object&& arg)
{ return static_cast<remove_reference<Object>::type&&>(arg); }
Copier après la connexion

Depuis que remove_reference convertit un objet en objet, nous nous retrouvons avec :

Object&& move(Object&& arg) { return static_cast<Object&&>(arg); }
Copier après la connexion

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

Cas 2 : Passer une Lvalue

Maintenant, le cas intéressant se présente 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);
Copier après la connexion

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

// move with [T = Object&]
remove_reference<Object&>::type&& move(Object& && arg)
{ return static_cast<remove_reference<Object&>::type&&>(arg); }
Copier après la connexion

Encore une fois, remove_reference convertit Object& en Object, ce qui donne :

Object&& move(Object& && arg) { return static_cast<Object&&>(arg); }
Copier après la connexion

À première vue, cela semble contre-intuitif puisque nous avons passé 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, Objet& && se comporte effectivement comme Objet& , une référence 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<Object&&>(arg); }
Copier après la connexion

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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal