Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Catégories de valeurs et sémantique de déplacement

Les catégories lvalue, prvalue et xvalue décrivent des expressions, pas des types de variables. Découvrez leurs regroupements glvalue et rvalue, ainsi que leur lien avec les références, le choix des surcharges et std::move, qui ne transfère pas lui-même les ressources.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

lvalue: x; prvalue: 42; xvalue: std::move(x); glvalue = lvalue | xvalue; rvalue = prvalue | xvalue

Chaque expression possède exactement une catégorie de valeur fondamentale : lvalue, prvalue ou xvalue. Un lvalue désigne un objet ou une fonction et n’est pas un xvalue ; un prvalue calcule une valeur ou initialise un objet ; un xvalue désigne un objet dont les ressources peuvent être réutilisées. glvalue regroupe lvalue et xvalue, tandis que rvalue regroupe prvalue et xvalue. La catégorie appartient à l’expression, pas au type d’une variable ; un lvalue n’a pas besoin d’être modifiable.

Une expression x qui nomme une variable ordinaire est généralement un lvalue. En C++23, si elle nomme une variable locale et remplit les conditions du déplacement implicite en tant qu’opérande d’une instruction return, c’est un xvalue. L’expression 42 est un prvalue et std::move(x), pour un objet, est un xvalue. Un type de déclaration T&& ne transforme pas chaque utilisation du nom en xvalue : dans l’exemple, rr est un lvalue. Lorsqu’un objet temporaire est nécessaire, la matérialisation d’un temporaire peut convertir un prvalue en un xvalue désignant cet objet.

std::move de <utility> effectue une conversion vers une référence rvalue ; il ne copie ni ne transfère lui-même les ressources. Il permet de sélectionner un constructeur de déplacement, généralement T(T&&), plutôt qu’un constructeur de copie T(const T&). L’action réelle dépend de la surcharge sélectionnée. Une copie peut tout de même être sélectionnée ; std::move conserve const, si bien que le constructeur habituel T(T&&) ne peut pas accepter un objet const. L’état de la source après un déplacement dépend du contrat du type : ne supposez pas que l’objet est vide.

L’exemple distingue la liaison d’une référence de la construction : l’initialisation de rr n’affiche rien, b(rr) copie et c(std::move(rr)) sélectionne le constructeur de déplacement. Les déclarations static_assert vérifient les catégories avec decltype ; les parenthèses dans decltype((rr)) sont importantes. Les constructeurs affichent uniquement des messages et ne gèrent aucune ressource. Cette entrée porte sur C++23 ; l’URL de la norme fournie mène à un projet évolutif, et non à une publication C++23 figée.

Exemples

#include <iostream>
#include <type_traits>
#include <utility>

struct Item {
    Item() = default;
    Item(const Item&) { std::cout << "copy\n"; }
    Item(Item&&) noexcept { std::cout << "move\n"; }
};

int main() {
    Item a;
    Item&& rr = std::move(a);

    static_assert(std::is_same_v<decltype((a)), Item&>);
    static_assert(std::is_same_v<decltype((rr)), Item&>);
    static_assert(std::is_same_v<decltype(std::move(a)), Item&&>);
    static_assert(std::is_same_v<decltype(Item{}), Item>);

    [[maybe_unused]] Item b(rr);
    [[maybe_unused]] Item c(std::move(rr));
}

Résultat

copy
move

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources