Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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.

Fonti