KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Declarator voor rvalue-referenties (`&&`)

De declarator `&&` vormt een rvalue-referentietype. Voor de keuze van een overload telt de waardecategorie van de expressie: de naam van een variabele met type `T&&` is als argument een lvalue.

Versie: ISO C++23; implementation support may vary

Syntax

T&& ref = expr;               // local reference; requires a suitable initializer
void consume(T&& arg);        // reference parameter
T&& access();                 // reference return type; does not extend lifetime
using R = T&&;                // reference type alias; collapsing can apply
template<class U> void relay(U&& arg);  // forwarding reference when U is deduced

In T&& ref declareert && een rvalue-referentie als T een objecttype en geen referentietype is. T& is een lvalue-referentie; in const T& kwalificeert const het object. Dit is niet de ingebouwde logische EN a && b, die de rechteroperand overslaat als de linker onwaar is, en ook niet de bitsgewijze EN a & b of de adresoperator &x. In void f() && is het teken een referentiekwalificatie van de lidfunctie. Rvalue-referenties bestaan sinds C++11; hier gelden de regels van ISO C++23.

Een gewone T&& kan niet rechtstreeks aan een lvalue van hetzelfde objecttype T binden. De referentie kan wel binden aan een prvalue, waarbij een tijdelijk object wordt gematerialiseerd, of aan een xvalue zoals std::move(x), die een bestaand object kan aanduiden. Als aanroepargument is de naam ref een lvalue, ook als die is gedeclareerd als T&&. Bij de overloads const int& en int&& in het voorbeeld kiest een rvalue van type int de overload int&&; een lvalue van type int of een xvalue van type const int kiest const int&.

Voor een object levert std::move uit <utility> een xvalue op: het verwijdert geen const en verplaatst zelf niets. Task(Task&&) en Task& operator=(Task&&) zijn gebruikelijke verplaatsingsoperaties; bij de tweede is Task& het retourtype. De operatie kan het eigendom van een resource, zoals een coroutineframe, overdragen; de referentiebinding doet dat niet. = delete bij een kopieeroperatie verbiedt het gebruik ervan. = default bij een verplaatsingsoperatie vraagt om de door de taal bepaalde implementatie, die alsnog als verwijderd kan gelden.

Een lokale declaratie T&& ref = T{}; verlengt de levensduur van dat tijdelijke object tot het einde van de levensduur van de referentie. Een tijdelijk object dat aan een referentieparameter bindt, leeft alleen tot het einde van de volledige expressie die de aanroep bevat. De referentie doorgeven verlengt die levensduur niet opnieuw. Geef geen referentie terug naar een lokaal object dat bij het verlaten van de functie wordt vernietigd.

In template<class U> void relay(U&& arg) is U&& bij deductie van U een doorgeefreferentie. Voor een lvalue van type T wordt U afgeleid als T& en levert het samenvallen van referenties T& op; voor een rvalue van type T is het resultaat T&&. Bij het samenvallen bepaalt een aanwezige & dat het resultaat & is; alleen twee && leveren && op. Gebruik std::forward<U>(arg) uit <utility> om het argument volgens de deductie als lvalue of rvalue door te geven. const U&& is geen doorgeefreferentie.

Voorbeelden

#include <iostream>
#include <utility>

void probe(const int&) { std::cout << "const int&\n"; }
void probe(int&&)      { std::cout << "int&&\n"; }

int main() {
    int value = 1;
    int&& ref = 2;
    const int frozen = 3;

    probe(value);
    probe(7);
    probe(ref);
    probe(std::move(ref));
    probe(std::move(frozen));
}

Resultaat

const int&
int&&
const int&
int&&
const int&

In de aanroep is `ref` een lvalue; `std::move(ref)` is een xvalue en kiest `int&&`. `std::move(frozen)` behoudt `const` en kiest dus `const int&`. Het programma toont de keuze van een overload, niet de overdracht van resources.

Gerelateerde lessen

  • C++ · Les 11 · Gevorderd · Versie: 3
  • C++ · Les 19 · Gevorderd · Versie: 3
  • C++ · Les 41 · Gevorderd · Versie: 3
  • C++ · Les 42 · Gevorderd · Versie: 3
  • C++ · Les 43 · Gevorderd · Versie: 3
  • C++ · Les 45 · Gevorderd · Versie: 3

Bronnen