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

Ils doivent être noexcept pour que le type se comporte bien avec les conteneurs et les algorithmes standards (sinon ils sont obligés de faire des copies).

class A {
    A(A && other) noexcept;                // move constructor
    A & operator = (A && other) noexcept;  // 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 de mai 2026.

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.