Leer Rvalue- en Lvalue-Referenties | Referentiegrondslagen

Veeg om het menu te tonen

De concepten lvalue en rvalue worden gebruikt om expressies in twee typen te classificeren: die met een stabiele locatie in het geheugen en die welke tijdelijk zijn.

Een lvalue (left value) is een expressie die verwijst naar een specifieke locatie in het geheugen. Simpel gezegd is het een variabele met een naam die u kunt wijzigen.

int x = 10;

Hier is x een lvalue omdat het een naam heeft, in het geheugen bestaat en de waarde kan worden aangepast (x = 20).

Een rvalue (right value) is een tijdelijke waarde zonder eigen naam, die alleen bestaat tijdens de evaluatie van een expressie.

10
x + 5

int y = x + 5;

Hier is x + 5 een rvalue omdat het slechts het resultaat is van een berekening, niet als een apart object wordt opgeslagen en niet direct kan worden aangepast.

Eenvoudig idee:

lvalue: iets met een naam en een geheugenadres (een variabele);
rvalue: een tijdelijk resultaat (een waarde of expressie).

Tijdelijke waarden

Een tijdelijke waarde is een kortlevend, intermediair resultaat dat wordt gecreëerd tijdens de evaluatie van een expressie.

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

Tijdelijke waarden worden automatisch beheerd door de compiler en bestaan gedurende de expressie of bewerking waarin ze zijn aangemaakt. Daarna worden ze doorgaans verwijderd en wordt het resultaat opgeslagen in de doelvariabele of gebruikt zoals nodig.

Move-semantiek

Een rvalue-referentie wordt aangeduid met een dubbele ampersand (&&).

Het enige verschil tussen een lvalue- en rvalue-referentie is dat een rvalue gebonden kan worden aan een tijdelijk object, terwijl een lvalue-referentie dat niet kan.

int&& ref_value = 5 * 5;

Opmerking

Het gebruik van een rvalue-referentie in deze context is mogelijk niet erg praktisch, aangezien er geen voordeel is bij het gebruik van een rvalue-referentie voor een eenvoudige literal.

Een combinatie van lvalue- en rvalue-referenties wordt gebruikt om move semantics te ondersteunen, waardoor resources kunnen worden overgedragen van het ene object naar het andere zonder onnodig kopiëren. Bekijk het onderstaande voorbeeld:

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

Maar we hebben geen kopieën van a of b nodig. We wilden ze gewoon omwisselen. Laten we het opnieuw proberen.

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(): transformeert een lvalue in een rvalue-referentie, maakt move-semantiek mogelijk en de overdracht van eigendom zonder te kopiëren.

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 3. Hoofdstuk 2

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Sectie 3. Hoofdstuk 2