CKTIS / C++
Riferimento rvalue: T&&
T&& dichiara un riferimento rvalue, un tipo distinto da T&. Si lega agli rvalue adatti e partecipa alla semantica di spostamento. Il nome di un riferimento, usato come espressione, è normalmente un lvalue. In C++23, però, un nome che può essere oggetto di spostamento implicito è un xvalue, per esempio quando il nome di un parametro di tipo riferimento rvalue a un tipo oggetto non qualificato con volatile è direttamente l'operando di un'istruzione return. T&& con un parametro di modello dedotto può essere un riferimento di inoltro.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
T&& name = expression;
void consume(T&& value);
template<class T> void relay(T&& value);Per un tipo oggetto T fisso e non di riferimento, T&& indica un riferimento rvalue; T& indica il distinto tipo di riferimento lvalue. Per esempio, int&& r = 7; lega r a un oggetto temporaneo. Un int&& non può legarsi direttamente a un lvalue di tipo int. Una definizione locale di riferimento deve essere inizializzata. Un'assegnazione successiva modifica l'oggetto referenziato, non l'oggetto a cui il riferimento si riferisce.
Il tipo di una dichiarazione e la categoria di valore di un'espressione sono due cose diverse. Nell'esempio, r ha tipo dichiarato int&&, ma l'espressione r è un lvalue. Di conseguenza, inspect(r) seleziona int&, mentre inspect(std::move(r)) seleziona int&&. std::move presenta un'espressione come xvalue; non trasferisce risorse da solo. Un costruttore o un operatore di assegnazione selezionato successivamente può eseguire uno spostamento.
Non ogni T&& è un normale parametro che accetta solo rvalue. In template<class T> void relay(T&& value);, quando T viene dedotto dall'argomento della chiamata, si tratta di un riferimento di inoltro: accetta lvalue e rvalue. Per un argomento lvalue di tipo int, T viene dedotto come int& e il collasso dei riferimenti produce int&. La regola è: solo && combinato con && dà &&; tutte le altre combinazioni danno &. Un parametro const T&& non è un riferimento di inoltro. Per inoltrare ulteriormente si usa std::forward<T>(value).
Un riferimento non garantisce che il suo oggetto esista ancora. Il legame diretto di un temporaneo in int&& r = 7; ne estende la durata fino alla fine della durata del riferimento locale. Un temporaneo legato a un parametro riferimento, tuttavia, vive solo fino alla fine dell'espressione completa che contiene la chiamata. Conservare quel riferimento non prolunga nuovamente la durata dell'oggetto e può lasciare un riferimento pendente.
Esempi
#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';
}
Risultato
lvalue rvalue rvalue 12
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.