C++ : Références Rvalue et Move

Sommaire :

• Type des values
• std::move
• Rvalue reference comme argument de fonction
• Rvalue reference comme argument template de fonction
• Move constructor et move assignment constructor
• Surcharges

Type des values

Type des values :

• - lvalue :
  • - peut être à gauche d'une affectation
  • - a un emplacement de stockage défini (a une adresse)
  • - généralement, a un nom
• - rvalue :
  • - ne peut que être à droite d'une affectation
  • - n'a pas d'emplacement de stockage défini (n'a pas d'adresse)
• - lvalue reference : &
  • - est liée obligatoirement à une lvalue
  • - sauf si est elle const : une lvalue reference const peut être liée à une rvalue
• - rvalue reference : &&
  • - est liée obligatoirement à une rvalue (une lvalue ne peut pas être liée à une rvalue reference)
  • - identifie un objet jetable, que l'on peut modifier, et sur lequel on peut légitimement faire un move

std::move

std::move est un cast en rvalue.

Rvalue reference comme argument de fonction

Lorsque l'argument d'une fonction est une rvalue reference :

• - On ne peut pas appeler la fonction avec une lvalue.
• - À l'intérieur de la fonction, l'argument est une lvalue : il a un nom et peut être modifié pour la suite de la fonction.

void toto(A && arg) {
    …
    arg = …
    …
}

toto(A());

A a;
toto(a);  // erreur de compilation : cannot bind rvalue reference of type 'A&&' to lvalue of type 'A'
toto(std::move(a));  // OK

Rvalue reference comme argument template de fonction

Lorsque l'argument template d'une fonction est une rvalue reference :

• - Si la fonction est appelée avec une lvalue, l'argument sera une lvalue reference.
• - Si la fonction est appelée avec une rvalue, l'argument sera une rvalue reference.

On appelle cela une forwarding reference ou universal reference. Cf Effective Modern C++ - Item 24 - Distinguish universal references from rvalue references .

Si la fonction template doit en appeler une autre, comme à l'intérieur de la fonction template l'argument est une lvalue, il faut utiliser std::forward pour préserver l'universalité de la référence :

template <typename T>
void tata(T && arg) {
    ...
}

template <typename T>
void toto(T && arg) {
    tata(std::forward<T>(arg));
}

Move constructor et move assignment constructor

class A {
    A(A && other);                // move constructor
    A & operator = (A && other);  // move assignment operator
};

Surcharges

Les “ref-qualifiers” permettent de définir des surcharges de méthodes, comme les “cv-qualifiers” (cv: const / volatile). Exemple :

class Foo {
public:
    Bar & get() & {
        return bar;
    }
    const Bar & get() const & {
        return bar;
    }
    Bar && get() && {
        return std::move(bar);
    }
private:
    Bar bar;
};

La dernière mise à jour de cette page date d'avril 2021.

Le contenu de ce site est, en tant qu'œuvre originale de l'esprit, protégé par le droit d'auteur.
Pour tout commentaire, vous pouvez m'écrire à xavier.lamorlette@gmail.com.