Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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 deduced

In 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