CKTIS / C++
Categorie di valore e semantica di spostamento
Le categorie lvalue, prvalue e xvalue descrivono le espressioni, non i tipi delle variabili. Scopri come si raggruppano in glvalue e rvalue e come si collegano ai riferimenti, alla scelta degli overload e a std::move, che da solo non trasferisce risorse.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
lvalue: x; prvalue: 42; xvalue: std::move(x); glvalue = lvalue | xvalue; rvalue = prvalue | xvalueOgni espressione ha esattamente una categoria di valore fondamentale: lvalue, prvalue oppure xvalue. Un lvalue identifica un oggetto o una funzione e non è un xvalue; un prvalue calcola un valore o inizializza un oggetto; un xvalue identifica un oggetto le cui risorse possono essere riutilizzate. glvalue comprende lvalue e xvalue, mentre rvalue comprende prvalue e xvalue. La categoria appartiene all’espressione, non al tipo di una variabile; un lvalue non deve necessariamente essere modificabile.
Un’espressione x che nomina una variabile ordinaria è di norma un lvalue. In C++23, se nomina una variabile locale e come operando di un’istruzione return soddisfa le condizioni per lo spostamento implicito, è un xvalue. L’espressione 42 è un prvalue e std::move(x), se x è un oggetto, è un xvalue. Il tipo dichiarato T&& non rende xvalue ogni uso del nome: nell’esempio, rr è un lvalue. Quando serve un oggetto temporaneo, la materializzazione di un temporaneo può convertire un prvalue in un xvalue che denota quell’oggetto.
std::move di <utility> effettua una conversione a riferimento rvalue; da solo non copia né trasferisce risorse. Consente di selezionare un costruttore di spostamento, di solito T(T&&), invece del costruttore di copia T(const T&). L’azione effettiva dipende dall’overload selezionato. Può comunque essere selezionata la copia; std::move conserva const, quindi il consueto costruttore T(T&&) non può accettare un oggetto const. Lo stato della sorgente dopo lo spostamento dipende dal contratto del tipo: non presumere che l’oggetto sia vuoto.
L’esempio distingue il legame di un riferimento dalla costruzione: inizializzare rr non stampa nulla, b(rr) copia e c(std::move(rr)) seleziona il costruttore di spostamento. Le dichiarazioni static_assert controllano le categorie tramite decltype; le parentesi in decltype((rr)) sono importanti. I costruttori stampano solo messaggi e non gestiscono risorse. Questa voce riguarda C++23; l’URL dello standard fornito rimanda a una bozza di lavoro in evoluzione, non a una pubblicazione C++23 definitiva e immutabile.
Esempi
#include <iostream>
#include <type_traits>
#include <utility>
struct Item {
Item() = default;
Item(const Item&) { std::cout << "copy\n"; }
Item(Item&&) noexcept { std::cout << "move\n"; }
};
int main() {
Item a;
Item&& rr = std::move(a);
static_assert(std::is_same_v<decltype((a)), Item&>);
static_assert(std::is_same_v<decltype((rr)), Item&>);
static_assert(std::is_same_v<decltype(std::move(a)), Item&&>);
static_assert(std::is_same_v<decltype(Item{}), Item>);
[[maybe_unused]] Item b(rr);
[[maybe_unused]] Item c(std::move(rr));
}
Risultato
copy move
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.