KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Rvalue-referentie: T&&

T&& declareert een rvalue-referentie, een ander type dan T&. Deze kan aan geschikte rvalues worden gebonden en speelt een rol bij move-semantiek. De naam van een referentie is als expressie normaal gesproken een lvalue. In C++23 is een naam die in aanmerking komt voor een impliciete move echter een xvalue. Dat geldt bijvoorbeeld als een parameternaam rechtstreeks als operand van een return-instructie wordt gebruikt en de parameter een rvalue-referentie naar een objecttype zonder volatile-kwalificatie is. T&& met een afgeleide templateparameter kan een forwarding reference zijn.

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

Syntax

T&& name = expression;
void consume(T&& value);
template<class T> void relay(T&& value);

Voor een vast objecttype T dat geen referentietype is, duidt T&& een rvalue-referentie aan; T& duidt het afzonderlijke lvalue-referentietype aan. Bijvoorbeeld: int&& r = 7; bindt r aan een tijdelijk object. Een int&& kan niet rechtstreeks aan een int-lvalue worden gebonden. Een lokale referentiedefinitie moet worden geïnitialiseerd. Een latere toewijzing verandert het object waarnaar wordt verwezen, niet het object dat de referentie aanduidt.

Het type van een declaratie en de waardecategorie van een expressie zijn verschillende dingen. In het voorbeeld heeft r het gedeclareerde type int&&, maar de expressie r is een lvalue. Daarom selecteert inspect(r) int&, terwijl inspect(std::move(r)) int&& selecteert. std::move biedt een expressie aan als xvalue; het verplaatst zelf geen resources. Een daarna geselecteerde constructor of toewijzingsoperator kan een verplaatsing uitvoeren.

Niet elke T&& is een gewone parameter die alleen rvalues accepteert. In template<class T> void relay(T&& value); is dit, wanneer T uit het aanroepargument wordt afgeleid, een forwarding reference: deze accepteert lvalues en rvalues. Bij een int-lvalue als argument wordt T afgeleid als int&, en levert het samenvoegen van referenties int& op. De regel is: alleen && gecombineerd met && levert && op; alle andere combinaties leveren & op. Een parameter const T&& is geen forwarding reference. Gebruik std::forward<T>(value) om verder door te geven.

Een referentie garandeert niet dat het object nog bestaat. Door een tijdelijk object rechtstreeks te binden in int&& r = 7; wordt de levensduur ervan verlengd tot het einde van de levensduur van de lokale referentie. Een tijdelijk object dat aan een referentieparameter is gebonden, leeft echter slechts tot het einde van de volledige expressie die de aanroep bevat. Die referentie bewaren verlengt de levensduur van het object niet opnieuw en kan een bungelende referentie opleveren.

Voorbeelden

#include <iostream>
#include <utility>

void inspect(int&) {
    std::cout << "lvalue\n";
}

void inspect(int&&) {
    std::cout << "rvalue\n";
}

int main() {
    int&& r = 7;
    inspect(r);
    inspect(std::move(r));
    inspect(9);
    r = 12;
    std::cout << r << '\n';
}

Resultaat

lvalue
rvalue
rvalue
12

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen