Rvalue- und Lvalue-Referenzen

Die Konzepte lvalue und rvalue beziehen sich auf die Klassifizierung von Ausdrücken.

lvalue oder linker Wert: ist ein Ausdruck, der sich auf ein Objekt mit identifizierbarem Speicherort bezieht. Es repräsentiert ein Objekt, das modifiziert werden kann;
rvalue oder rechter Wert: ist ein Ausdruck, der einen temporären oder wegwerfbaren Wert darstellt.

Temporäre Werte

Ein temporärer Wert ist ein kurzlebiges, intermediäres Ergebnis, das während der Auswertung eines Ausdrucks erstellt wird.

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);

Temporäre Werte werden automatisch vom Compiler verwaltet und existieren für die Dauer des Ausdrucks oder der Operation, in der sie erstellt werden. Danach werden sie typischerweise verworfen, und das Ergebnis wird in der Zielvariablen gespeichert oder nach Bedarf verwendet.

Move-Semantik

Ein rvalue-Referenz wird durch das doppelte Und-Zeichen (&&) bezeichnet.

Der einzige Unterschied zwischen einer lvalue- und einer rvalue-Referenz besteht darin, dass rvalue an ein temporäres Objekt gebunden werden kann, während eine lvalue-Referenz dies nicht kann.

Hinweis

Die Verwendung eines Rvalue-Referenz in diesem Kontext ist möglicherweise nicht sehr praktisch, da es keinen Vorteil bringt, eine Rvalue-Referenz für ein einfaches Literal zu verwenden.

Eine Kombination aus Lvalue- und Rvalue-Referenzen wird verwendet, um Move-Semantik zu unterstützen, die es ermöglicht, Ressourcen von einem Objekt auf ein anderes zu übertragen, ohne unnötiges Kopieren. Schauen Sie sich das folgende Beispiel an:

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`
}

Aber wir brauchen keine Kopien von a oder b. Wir wollten sie einfach nur vertauschen. Versuchen wir es noch einmal.

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(): wandelt ein lvalue in eine rvalue-Referenz um, ermöglicht Move-Semantik und den Transfer oder Besitz ohne Kopieren.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 3