Qu'est-ce que std :: move () et quand doit-il être utilisé?

1. Qu'Est-ce que c'est?
2. Qu'est ce que ça fait?
3. Quand faut-il l'utiliser?

De bons liens sont appréciés.

Page Wikipedia sur les références de valeur R C ++ 11 et les constructeurs de déplacement

1. En C ++ 11, en plus de copier des constructeurs, les objets peuvent avoir des constructeurs de déplacement.
   (Et en plus de copier les opérateurs d'affectation, ils ont des opérateurs d'affectation de déplacement.)
2. Le constructeur de déplacement est utilisé à la place du constructeur de copie, si l'objet a le type "rvalue-reference" ( Type &&).
3. std::move() est un transtypage qui produit une rvalue-référence à un objet, pour permettre son déplacement.

C'est une nouvelle façon C ++ d'éviter les copies. Par exemple, en utilisant un constructeur de déplacement, un std::vectorpourrait simplement copier son pointeur interne vers des données vers le nouvel objet, laissant l'objet déplacé dans un état déplacé de, donc ne copiant pas toutes les données. Ce serait C ++ - valide.

Essayez de googler pour la sémantique des mouvements, la valeur r, la transmission parfaite.

1. "Qu'est-ce que c'est?"

Bien que ce std::move() soit techniquement une fonction - je dirais que ce n'est pas vraiment une fonction . C'est une sorte de convertisseur entre les façons dont le compilateur considère la valeur d'une expression.

2. "Que fait-il?"

La première chose à noter est que std::move() rien ne bouge réellement . Il convertit une expression qui est une lvalue (telle qu'une variable nommée) en une xvalue . Une valeur x indique au compilateur:

Vous pouvez me piller, déplacer tout ce que je tiens et l'utiliser ailleurs (car je vais bientôt être détruit) ".

en d'autres termes, lorsque vous utilisez std::move(x), vous autorisez le compilateur à cannibaliser x. Ainsi, si xa, disons, son propre tampon en mémoire - après std::move()ing le compilateur peut avoir un autre objet le posséder à la place.

_{Vous pouvez également passer d'une valeur (telle qu'une valeur temporaire que vous passez), mais cela est rarement utile.}

3. "Quand faut-il l'utiliser?"

Une autre façon de poser cette question est la suivante: "Pourquoi cannibaliser les ressources d'un objet existant?" eh bien, si vous écrivez du code d'application, vous ne vous amuseriez probablement pas beaucoup avec des objets temporaires créés par le compilateur. Donc, vous le feriez principalement dans des endroits comme les constructeurs, les méthodes d'opérateur, les fonctions de type algorithme de bibliothèque standard, etc. Bien sûr, ce n'est qu'une règle d'or.

Une utilisation typique consiste à «déplacer» des ressources d'un objet à un autre au lieu de les copier. @Guillaume renvoie à cette page qui a un court exemple simple: échanger deux objets avec moins de copie.

template <class T>
swap(T& a, T& b) {
    T tmp(a);   // we now have two copies of a
    a = b;      // we now have two copies of b (+ discarded a copy of a)
    b = tmp;    // we now have two copies of tmp (+ discarded a copy of b)
}

utiliser move vous permet d'échanger les ressources au lieu de les copier:

template <class T>
swap(T& a, T& b) {
    T tmp(std::move(a));
    a = std::move(b);   
    b = std::move(tmp);
}

Pensez à ce qui se passe quand T, disons, vector<int>de taille n. Dans la première version, vous lisez et écrivez 3 * n éléments, dans la deuxième version, vous lisez et écrivez simplement les 3 pointeurs vers les tampons des vecteurs, plus les 3 tailles des tampons. Bien sûr, la classe Tdoit savoir comment bouger; votre classe doit avoir un opérateur d'affectation de mouvement et un constructeur de mouvement pour que la classe Tfonctionne.

Vous pouvez utiliser move lorsque vous devez "transférer" le contenu d'un objet ailleurs, sans faire de copie (c'est-à-dire que le contenu n'est pas dupliqué, c'est pourquoi il pourrait être utilisé sur certains objets non copiables, comme un unique_ptr). Il est également possible pour un objet de prendre le contenu d'un objet temporaire sans faire de copie (et gagner beaucoup de temps), avec std :: move.

Ce lien m'a vraiment aidé:

http://thbecker.net/articles/rvalue_references/section_01.html

Je suis désolé si ma réponse arrive trop tard, mais je cherchais également un bon lien pour le std :: move, et j'ai trouvé les liens ci-dessus un peu "austères".

Cela met l'accent sur la référence r-value, dans quel contexte vous devez les utiliser, et je pense que c'est plus détaillé, c'est pourquoi j'ai voulu partager ce lien ici.

Q: Qu'est-ce que c'est std::move?

A: std::move()est une fonction de la bibliothèque standard C ++ pour la conversion en une référence rvalue.

Simplement std::move(t)équivaut à:

static_cast<T&&>(t);

Une valeur r est une valeur temporaire qui ne persiste pas au-delà de l'expression qui la définit, comme un résultat de fonction intermédiaire qui n'est jamais stocké dans une variable.

int a = 3; // 3 is a rvalue, does not exist after expression is evaluated
int b = a; // a is a lvalue, keeps existing after expression is evaluated

Une implémentation de std :: move () est donnée dans N2027: "Une brève introduction aux références Rvalue" comme suit:

template <class T>
typename remove_reference<T>::type&&
std::move(T&& a)
{
    return a;
}

Comme vous pouvez le voir, std::moveretourne T&&peu importe s'il est appelé avec une valeur ( T), un type de référence ( T&) ou une référence rvalue ( T&&).

Q: Que fait-il?

R: En tant que distribution, il ne fait rien pendant l'exécution. Il est uniquement pertinent au moment de la compilation d'indiquer au compilateur que vous souhaitez continuer à considérer la référence comme une valeur r.

foo(3 * 5); // obviously, you are calling foo with a temporary (rvalue)

int a = 3 * 5;
foo(a);     // how to tell the compiler to treat `a` as an rvalue?
foo(std::move(a)); // will call `foo(int&& a)` rather than `foo(int a)` or `foo(int& a)`

Ce qu'il ne fait pas :

• Faites une copie de l'argument
• Appelez le constructeur de copie
• Changer l'objet argument

Q: Quand faut-il l'utiliser?

R: Vous devez utiliser std::movesi vous souhaitez appeler des fonctions qui prennent en charge la sémantique de déplacement avec un argument qui n'est pas une rvalue (expression temporaire).

Cela me pose les questions de suivi suivantes:

• Qu'est-ce que la sémantique des mouvements? Déplacer la sémantique contrairement à copier la sémantique est une technique de programmation dans laquelle les membres d'un objet sont initialisés en «prenant le relais» au lieu de copier les membres d'un autre objet. Une telle «prise en charge» n'a de sens qu'avec des pointeurs et des descripteurs de ressources, qui peuvent être transférés à moindre coût en copiant le pointeur ou le descripteur d'entier plutôt que les données sous-jacentes.

• Quels types de classes et d'objets prennent en charge la sémantique de déplacement? C'est à vous, en tant que développeur, d'implémenter la sémantique des mouvements dans vos propres classes si celles-ci ont intérêt à transférer leurs membres au lieu de les copier. Une fois que vous aurez implémenté la sémantique de déplacement, vous bénéficierez directement du travail de nombreux programmeurs de bibliothèque qui ont ajouté la prise en charge de la gestion efficace des classes avec la sémantique de déplacement.

• Pourquoi le compilateur ne peut-il pas le comprendre par lui-même? Le compilateur ne peut pas simplement appeler une autre surcharge d'une fonction sauf si vous le dites. Vous devez aider le compilateur à choisir si la version régulière ou la fonction de déplacement doit être appelée.

• Dans quelles situations voudrais-je dire au compilateur qu'il doit traiter une variable comme une valeur r? Cela se produira très probablement dans les fonctions de modèle ou de bibliothèque, où vous savez qu'un résultat intermédiaire pourrait être récupéré.

std :: move lui-même ne fait pas grand-chose. Je pensais qu'il appelait le constructeur déplacé pour un objet, mais il effectue simplement un transtypage de type (transtypage d'une variable lvalue en rvalue afin que ladite variable puisse être passée en argument à un constructeur de déplacement ou à un opérateur d'affectation).

Donc std :: move est juste utilisé comme précurseur de l'utilisation de la sémantique de déplacement. Déplacer la sémantique est essentiellement un moyen efficace de traiter des objets temporaires.

Considérez l'objet A = B + C + D + E + F;

C'est un joli code, mais E + F produit un objet temporaire. Ensuite, D + temp produit un autre objet temporaire et ainsi de suite. Dans chaque opérateur "+" normal d'une classe, des copies complètes se produisent.

Par exemple

Object Object::operator+ (const Object& rhs) {
    Object temp (*this);
    // logic for adding
    return temp;
}

La création de l'objet temporaire dans cette fonction est inutile - ces objets temporaires seront de toute façon supprimés à la fin de la ligne car ils seront hors de portée.

Nous pouvons plutôt utiliser la sémantique des mouvements pour "piller" les objets temporaires et faire quelque chose comme

 Object& Object::operator+ (Object&& rhs) {
     // logic to modify rhs directly
     return rhs;
 }

Cela évite de faire des copies profondes inutiles. En référence à l'exemple, la seule partie où la copie en profondeur se produit est maintenant E + F. Le reste utilise la sémantique de déplacement. Le constructeur de déplacement ou l'opérateur d'affectation doit également être implémenté pour affecter le résultat à A.

"Qu'Est-ce que c'est?" et "Que fait-il?" a été expliqué ci-dessus.

Je vais donner un exemple de "quand il doit être utilisé".

Par exemple, nous avons une classe avec beaucoup de ressources comme un grand tableau.

class ResHeavy{ //  ResHeavy means heavy resource
    public:
        ResHeavy(int len=10):_upInt(new int[len]),_len(len){
            cout<<"default ctor"<<endl;
        }

        ResHeavy(const ResHeavy& rhs):_upInt(new int[rhs._len]),_len(rhs._len){
            cout<<"copy ctor"<<endl;
        }

        ResHeavy& operator=(const ResHeavy& rhs){
            _upInt.reset(new int[rhs._len]);
            _len = rhs._len;
            cout<<"operator= ctor"<<endl;
        }

        ResHeavy(ResHeavy&& rhs){
            _upInt = std::move(rhs._upInt);
            _len = rhs._len;
            rhs._len = 0;
            cout<<"move ctor"<<endl;
        }

    // check array valid
    bool is_up_valid(){
        return _upInt != nullptr;
    }

    private:
        std::unique_ptr<int[]> _upInt; // heavy array resource
        int _len; // length of int array
};

Code de test:

void test_std_move2(){
    ResHeavy rh; // only one int[]
    // operator rh

    // after some operator of rh, it becomes no-use
    // transform it to other object
    ResHeavy rh2 = std::move(rh); // rh becomes invalid

    // show rh, rh2 it valid
    if(rh.is_up_valid())
        cout<<"rh valid"<<endl;
    else
        cout<<"rh invalid"<<endl;

    if(rh2.is_up_valid())
        cout<<"rh2 valid"<<endl;
    else
        cout<<"rh2 invalid"<<endl;

    // new ResHeavy object, created by copy ctor
    ResHeavy rh3(rh2);  // two copy of int[]

    if(rh3.is_up_valid())
        cout<<"rh3 valid"<<endl;
    else
        cout<<"rh3 invalid"<<endl;
}

sortie comme ci-dessous:

default ctor
move ctor
rh invalid
rh2 valid
copy ctor
rh3 valid

Nous pouvons voir std::movequ'avec move constructorrend la ressource de transformation facilement.

Où d'autre est std::moveutile?

std::movepeut également être utile lors du tri d'un tableau d'éléments. De nombreux algorithmes de tri (tels que le tri par sélection et le tri par bulles) fonctionnent en échangeant des paires d'éléments. Auparavant, nous avons dû recourir à la sémantique de copie pour effectuer l'échange. Nous pouvons maintenant utiliser la sémantique de déplacement, qui est plus efficace.

Cela peut également être utile si nous voulons déplacer le contenu géré par un pointeur intelligent vers un autre.

Cité:

• https://www.learncpp.com/cpp-tutorial/15-4-stdmove/

Voici un exemple complet, en utilisant std :: move pour un vecteur personnalisé (simple)

Production attendue:

 c: [10][11]
 copy ctor called
 copy of c: [10][11]
 move ctor called
 moved c: [10][11]

Compiler en tant que:

  g++ -std=c++2a -O2 -Wall -pedantic foo.cpp

Code:

#include <iostream>
#include <algorithm>

template<class T> class MyVector {
private:
    T *data;
    size_t maxlen;
    size_t currlen;
public:
    MyVector<T> () : data (nullptr), maxlen(0), currlen(0) { }
    MyVector<T> (int maxlen) : data (new T [maxlen]), maxlen(maxlen), currlen(0) { }

    MyVector<T> (const MyVector& o) {
        std::cout << "copy ctor called" << std::endl;
        data = new T [o.maxlen];
        maxlen = o.maxlen;
        currlen = o.currlen;
        std::copy(o.data, o.data + o.maxlen, data);
    }

    MyVector<T> (const MyVector<T>&& o) {
        std::cout << "move ctor called" << std::endl;
        data = o.data;
        maxlen = o.maxlen;
        currlen = o.currlen;
    }

    void push_back (const T& i) {
        if (currlen >= maxlen) {
            maxlen *= 2;
            auto newdata = new T [maxlen];
            std::copy(data, data + currlen, newdata);
            if (data) {
                delete[] data;
            }
            data = newdata;
        }
        data[currlen++] = i;
    }

    friend std::ostream& operator<<(std::ostream &os, const MyVector<T>& o) {
        auto s = o.data;
        auto e = o.data + o.currlen;;
        while (s < e) {
            os << "[" << *s << "]";
            s++;
        }
        return os;
    }
};

int main() {
    auto c = new MyVector<int>(1);
    c->push_back(10);
    c->push_back(11);
    std::cout << "c: " << *c << std::endl;
    auto d = *c;
    std::cout << "copy of c: " << d << std::endl;
    auto e = std::move(*c);
    delete c;
    std::cout << "moved c: " << e << std::endl;
}