Références Rvalue et Lvalue

Les concepts lvalue et rvalue sont liés à la classification des expressions.

lvalue ou valeur gauche : est une expression qui fait référence à un objet avec un emplacement mémoire identifiable. Elle représente un objet pouvant être modifié;
rvalue ou valeur droite : est une expression qui représente une valeur temporaire ou éphémère.

Valeurs Temporaires

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

rvalue


              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 elles existent pendant toute la durée de l'expression ou de l'opération dans laquelle elles sont créées. Par la suite, elles sont généralement rejetées, et le résultat est stocké dans la variable cible ou utilisé selon les besoins.

Sémantique de mouvement

Une référence rvalue est notée par le double esperluette (&&).

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

Remarque

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

Une combinaison de références lvalue et rvalue est utilisée pour supporter les sémantiques de déplacement, permettant le transfert de ressources d'un objet à un autre sans copies inutiles. Regardez l'exemple ci-dessous:

swap


              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 de b. Nous voulions simplement les échanger. Essayons encore.

main


              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 3