Apprendre Références Rvalue et Lvalue | Fondamentaux des Références

Glissez pour afficher le menu

Les concepts de lvalue et rvalue sont utilisés pour classer les expressions en deux types : celles qui possèdent un emplacement stable en mémoire et celles qui sont temporaires.

Une lvalue (left value) est une expression qui fait référence à un emplacement spécifique en mémoire. En termes simples, il s'agit d'une variable nommée que l'on peut modifier.

int x = 10;

Ici, x est une lvalue car elle possède un nom, existe en mémoire et sa valeur peut être modifiée (x = 20).

Une rvalue (right value) est une valeur temporaire qui ne possède pas de nom propre et n'existe que pendant l'évaluation d'une expression.

10
x + 5

int y = x + 5;

Ici, x + 5 est une rvalue car il s'agit simplement du résultat d'un calcul, non stocké comme un objet distinct, et qui ne peut pas être modifié directement.

Idée simple :

lvalue : élément possédant un nom et une adresse mémoire (une variable) ;
rvalue : résultat temporaire (une valeur ou une expression).

Valeurs temporaires

Une valeur temporaire est un résultat intermédiaire de courte durée créé lors de l'évaluation d'une expression.

rvalue.h


              12345678
            
// `(27 + 6 + 3 + 2)` is a tempopary value
int sum = 27 + 6 + 3 + 2;

// `static_cast<float>(sum)` is a tempopary value
float avarage = static_cast<float>(sum) / count;

// std::max(7, 9) will return a tempopary value
int largest = std::max(7, 9);

Les valeurs temporaires sont automatiquement gérées par le compilateur et existent pendant la durée de l'expression ou de l'opération où elles sont créées. Ensuite, elles sont généralement supprimées, et le résultat est stocké dans la variable cible ou utilisé selon les besoins.

Sémantique de déplacement

Une référence à valeur r est indiquée par le double esperluette (&&).

La seule différence entre une référence à valeur l et une référence à valeur r est que la valeur r peut être liée à un objet temporaire, alors qu'une référence à valeur l ne le peut pas.

int&& ref_value = 5 * 5;

Remarque

L'utilisation d'une référence à valeur r dans ce contexte peut ne pas être très pratique, car il n'y a aucun avantage à utiliser une référence à valeur r pour un simple littéral.

Une combinaison de références lvalue et rvalue est utilisée pour prendre en charge la sémantique de déplacement, permettant le transfert de ressources d'un objet à un autre sans copie inutile. Consultez l'exemple ci-dessous :

swap.h


              123456
            
std::string swap(std::string& a, std::string& b)
{
    std::string tmp(a); // We have two copies of string `a`
    a = b; // Now we have two copies of string `b`
    b = tmp; // And now we have two copies of string `tmp`
}

Mais nous n'avons pas besoin de copies de a ou b. Nous voulions simplement les échanger. Essayons à nouveau.

main.cpp


              1234567891011121314151617181920212223
            
#include <iostream>

void swap(std::string &a, std::string &b)
{
    // Move the content of a into temp
    std::string temp(std::move(a));
  
	// Move the content of b into a
    a = std::move(b);

    // Move the content of temp into b
    b = std::move(temp);
}

int main()
{
	std::string a = "Hello\n";
	std::string b = "Bye\n";

	swap(a, b);

 	std::cout << a << b;
}

std::move(): transforme une lvalue en une référence rvalue, permettant la sémantique de déplacement et le transfert de propriété sans copie.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 2

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Section 3. Chapitre 2