0Pricing
C++ Academy · Lezione

Riferimenti rvalue e sintassi &&

Leghi temporanei con riferimenti rvalue per trasferire risorse in modo efficiente

Riferimenti rvalue e sintassi && è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

La sintassi &&

Un riferimento rvalue viene dichiarato con T&&. Si associa solo agli rvalue, cioè ai temporanei che stanno per essere distrutti.

int&& ref = 42;          // OK: binds to literal
int x = 10;
// int&& bad = x;        // ERROR: x is an lvalue

Perché esistono i riferimenti rvalue?

Consentono di scrivere funzioni che sanno che l'argomento sta per essere distrutto. È quindi possibile acquisirne le risorse senza effettuare una copia.

Overload di una funzione in base al tipo di riferimento

È possibile creare overload di una funzione per T& e T&&. Il compilatore sceglie quello corretto in base alla categoria dell'argomento.

void process(std::string& s) { std::cout << "lvalue\n"; }
void process(std::string&& s) { std::cout << "rvalue\n"; }

std::string s = "hi";
process(s);            // lvalue
process("temp");       // rvalue
process(std::move(s)); // rvalue

I riferimenti rvalue con nome diventano lvalue

Quando si assegna un nome a un riferimento rvalue, quel nome è a sua volta un lvalue: la sua identità è stata stabilita. Usi std::move per recuperare la natura rvalue.

void f(std::string&& s) {
    // inside f, the parameter s is an lvalue
    g(s);              // passes s by lvalue
    h(std::move(s));   // passes s as an rvalue
}

std::move è un cast

std::move(x) non sposta nulla da solo: è un cast di tipo che restituisce x come riferimento rvalue. Lo spostamento effettivo avviene nel costruttore che riceve il valore.

// equivalent to
static_cast<std::string&&>(s)

Perché si chiama move

Il nome riflette l'uso tipico: passare un oggetto di cui si intendono acquisire i contenuti. Tuttavia, da solo non trasferisce nulla.

Riferimenti universali (forwarding references)

Quando T&& compare in un template con T dedotto, è un forwarding reference: si associa sia agli lvalue sia agli rvalue, preservandone la categoria.

template <typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg));
}

Collasso dei riferimenti

Quando i riferimenti si combinano attraverso i template, il linguaggio li riduce secondo queste regole:

  • T& & → T&
  • T& && → T&
  • T&& & → T&
  • T&& && → T&&

Quando non usare move

Per i tipi copiabili trivialmente (int, double, puntatori), lo spostamento equivale alla copia. Chiamare std::move non offre alcun vantaggio e può confondere chi legge.

Spostare senza possedere risorse

Per i tipi privi di risorse sull'heap, il costruttore di spostamento è uguale al costruttore di copia. Lo spostamento è utile solo per i tipi che possiedono memoria dinamica.

Problema comune: spostare da const

Applicare std::move a un oggetto const non ha effetto: il costruttore di spostamento non può essere chiamato su un const perché dovrebbe modificare la sorgente.

Verifica rapida

Che cosa fa realmente std::move(x)?

Riepilogo

T&& si associa agli rvalue. I riferimenti rvalue con nome diventano lvalue: usi std::move per recuperare la natura rvalue. In un template, T&& è un forwarding reference. std::move è un cast; non esegue direttamente lo spostamento.

Domande Frequenti

La lezione «Riferimenti rvalue e sintassi &&» è gratuita?

Sì — il testo completo di «Riferimenti rvalue e sintassi &&» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Riferimenti rvalue e sintassi &&»?

Leghi temporanei con riferimenti rvalue per trasferire risorse in modo efficiente Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Riferimenti rvalue e sintassi &&»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Lvalue e rvalue: la distinzione
  2. Riferimenti rvalue e sintassi &&
  3. std::move e std::forward
  4. Costruttori di move e assegnazione di move
← Torna a C++ Academy