CKTIS / C++
Dichiaratore di riferimento a rvalue (`&&`)
Il dichiaratore `&&` forma un tipo riferimento a rvalue. La risoluzione degli overload dipende però dalla categoria dell’espressione: il nome di una variabile dichiarata `T&&` è un lvalue quando è usato come argomento.
Versione: ISO C++23; implementation support may vary
Sintassi
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 deducedIn T&& ref, se T è un tipo oggetto e non un tipo riferimento, && dichiara un riferimento a rvalue. T& è un riferimento a lvalue; in const T&, const qualifica l’oggetto. Non è l’AND logico predefinito a && b, che non valuta l’operando destro se quello sinistro è falso, né l’AND bit a bit a & b, né l’operatore di indirizzo &x. In void f() && è un qualificatore di riferimento della funzione membro. I riferimenti a rvalue esistono da C++11; qui si applicano le regole di ISO C++23.
Un normale T&& non può legarsi direttamente a un lvalue dello stesso tipo oggetto T. Può legarsi a un prvalue, che materializza un oggetto temporaneo per il legame, o a un xvalue come std::move(x), che può designare un oggetto esistente. Come argomento di una chiamata, il nome ref è un lvalue anche se dichiarato T&&. Con gli overload const int& e int&& dell’esempio, un rvalue di tipo int seleziona int&&; un lvalue di tipo int o un xvalue di tipo const int seleziona const int&.
Per un oggetto, std::move da <utility> produce un xvalue: non rimuove const e non sposta nulla da solo. Task(Task&&) e Task& operator=(Task&&) sono tipiche operazioni di spostamento; nella seconda, Task& è il tipo restituito. L’operazione può trasferire la proprietà di una risorsa, ad esempio il frame di una coroutine, ma il legame del riferimento non la trasferisce. Nelle operazioni di copia, = delete ne vieta l’uso; in un’operazione di spostamento, = default richiede l’implementazione prevista dal linguaggio, che può comunque risultare eliminata.
La dichiarazione locale T&& ref = T{}; estende la vita del temporaneo fino al termine della vita del riferimento. Un temporaneo legato a un parametro riferimento vive solo fino alla fine dell’espressione completa che contiene la chiamata. Passare il riferimento ad altri non estende di nuovo la durata dell’oggetto. Non restituire un riferimento a un oggetto locale distrutto all’uscita dalla funzione.
In template<class U> void relay(U&& arg), U&& è un riferimento di inoltro quando U viene dedotto. Per un lvalue di tipo T, U è dedotto come T& e il collasso dei riferimenti dà T&; per un rvalue di tipo T il risultato è T&&. Nel collasso, se compare almeno un & il risultato è &; solo due && danno &&. Usa std::forward<U>(arg) da <utility> per inoltrare l’argomento come lvalue o rvalue secondo la deduzione. const U&& non è un riferimento di inoltro.
Esempi
#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));
}
Risultato
const int& int&& const int& int&& const int&
Nella chiamata, `ref` è un lvalue, mentre `std::move(ref)` è un xvalue e seleziona `int&&`. `std::move(frozen)` mantiene `const`, quindi seleziona `const int&`. Il programma mostra la risoluzione degli overload, non un trasferimento di risorse.
Lezioni correlate
- C++ · Lezione 11 · Avanzato · Versione: 3
- C++ · Lezione 19 · Avanzato · Versione: 3
- C++ · Lezione 41 · Avanzato · Versione: 3
- C++ · Lezione 42 · Avanzato · Versione: 3
- C++ · Lezione 43 · Avanzato · Versione: 3
- C++ · Lezione 45 · Avanzato · Versione: 3
Fonti
- Working Draft, Standard for Programming Language C++ (N4950)
- References [dcl.ref]
- Reference initialization [dcl.init.ref]
- Value category [basic.lval]
- Temporary objects [class.temporary]
- Deducing template arguments from a function call [temp.deduct.call]
- Forward/move helpers [forward]
- Ranking implicit conversion sequences [over.ics.rank]
- Copy/move constructors [class.copy.ctor]
- Copy/move assignment operator [class.copy.assign]
- Compound expressions [expr.compound]
- Functions [dcl.fct]