Comment std :: move () transfère-t-il les valeurs dans RValues?

Je me suis juste retrouvé à ne pas comprendre pleinement la logique de std::move().

Au début, je l'ai recherché sur Google, mais il semble qu'il n'y ait que des documents sur la façon de l'utiliser std::move(), pas sur le fonctionnement de sa structure.

Je veux dire, je sais ce qu'est la fonction de membre du modèle, mais quand je regarde la std::move()définition dans VS2010, cela reste déroutant.

la définition de std :: move () va ci-dessous.

template<class _Ty> inline
typename tr1::_Remove_reference<_Ty>::_Type&&
    move(_Ty&& _Arg)
    {   // forward _Arg as movable
        return ((typename tr1::_Remove_reference<_Ty>::_Type&&)_Arg);
    }

Ce qui m'est étrange en premier, c'est le paramètre (_Ty && _Arg), car lorsque j'appelle la fonction comme vous le voyez ci-dessous,

// main()
Object obj1;
Object obj2 = std::move(obj1);

cela équivaut fondamentalement à

// std::move()
_Ty&& _Arg = Obj1;

Mais comme vous le savez déjà, vous ne pouvez pas directement lier une LValue à une référence RValue, ce qui me fait penser qu'il devrait en être ainsi.

_Ty&& _Arg = (Object&&)obj1;

Cependant, c'est absurde car std :: move () doit fonctionner pour toutes les valeurs.

Donc, je suppose que pour bien comprendre comment cela fonctionne, je devrais également jeter un coup d'œil à ces structures.

template<class _Ty>
struct _Remove_reference
{   // remove reference
    typedef _Ty _Type;
};

template<class _Ty>
struct _Remove_reference<_Ty&>
{   // remove reference
    typedef _Ty _Type;
};

template<class _Ty>
struct _Remove_reference<_Ty&&>
{   // remove rvalue reference
    typedef _Ty _Type;
};

Malheureusement, c'est toujours aussi déroutant et je ne comprends pas.

Je sais que tout cela est dû à mon manque de compétences de base en syntaxe sur C ++. J'aimerais savoir comment ils fonctionnent à fond et tous les documents que je peux obtenir sur Internet seront plus que bienvenus. (Si vous pouvez simplement expliquer cela, ce sera génial aussi).

Nous commençons par la fonction de déplacement (que j'ai nettoyée un peu):

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

Commençons par la partie la plus simple - c'est-à-dire lorsque la fonction est appelée avec rvalue:

Object a = std::move(Object());
// Object() is temporary, which is prvalue

et notre movemodèle est instancié comme suit:

// move with [T = Object]:
remove_reference<Object>::type&& move(Object&& arg)
{
  return static_cast<remove_reference<Object>::type&&>(arg);
}

Puisque remove_referenceconvertit T&en Tou T&&en T, et Objectn'est pas une référence, notre fonction finale est:

Object&& move(Object&& arg)
{
  return static_cast<Object&&>(arg);
}

Maintenant, vous vous demandez peut-être: avons-nous même besoin du casting? La réponse est: oui, nous le faisons. La raison est simple; La référence nommée rvalue est traitée comme lvalue (et la conversion implicite de lvalue en référence rvalue est interdite par la norme).

Voici ce qui se passe lorsque nous appelons moveavec lvalue:

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

et moveinstanciation correspondante :

// move with [T = Object&]
remove_reference<Object&>::type&& move(Object& && arg)
{
  return static_cast<remove_reference<Object&>::type&&>(arg);
}

Encore une fois, remove_referenceconvertis Object&à Objectet nous obtenons:

Object&& move(Object& && arg)
{
  return static_cast<Object&&>(arg);
}

Maintenant, nous arrivons à la partie délicate: que signifie Object& &&même et comment peut-il se lier à lvalue?

Pour permettre un transfert parfait, la norme C ++ 11 fournit des règles spéciales pour la réduction des références, qui sont les suivantes:

Object &  &  = Object &
Object &  && = Object &
Object && &  = Object &
Object && && = Object &&

Comme vous pouvez le voir, sous ces règles Object& &&signifie en fait Object&, qui est une simple référence lvalue qui permet de lier les lvalues.

La fonction finale est donc:

Object&& move(Object& arg)
{
  return static_cast<Object&&>(arg);
}

ce qui n'est pas différent de l'instanciation précédente avec rvalue - ils convertissent tous les deux son argument en rvalue reference puis le renvoient. La différence est que la première instanciation ne peut être utilisée qu'avec rvalues, tandis que la seconde fonctionne avec lvalues.

Pour expliquer pourquoi nous avons besoin d' remove_referenceun peu plus, essayons cette fonction

template <typename T>
T&& wanna_be_move(T&& arg)
{
  return static_cast<T&&>(arg);
}

et instanciez-le avec lvalue.

// wanna_be_move [with T = Object&]
Object& && wanna_be_move(Object& && arg)
{
  return static_cast<Object& &&>(arg);
}

En appliquant les règles de réduction de référence mentionnées ci-dessus, vous pouvez voir que nous obtenons une fonction qui est inutilisable move(pour le dire simplement, vous l'appelez avec lvalue, vous récupérez lvalue). Si quoi que ce soit, cette fonction est la fonction d'identité.

Object& wanna_be_move(Object& arg)
{
  return static_cast<Object&>(arg);
}

_Ty est un paramètre de modèle, et dans cette situation

Object obj1;
Object obj2 = std::move(obj1);

_Ty est de type "Objet &"

c'est pourquoi la _Remove_reference est nécessaire.

Ce serait plus comme

typedef Object& ObjectRef;
Object obj1;
ObjectRef&& obj1_ref = obj1;
Object&& obj2 = (Object&&)obj1_ref;

Si nous ne supprimions pas la référence, ce serait comme nous le faisions

Object&& obj2 = (ObjectRef&&)obj1_ref;

Mais ObjectRef && se réduit à Object &, que nous n'avons pas pu lier à obj2.

La raison pour laquelle il réduit de cette manière est de soutenir une transmission parfaite. Voir cet article .