CKTIS / C++
Waardecategorieën en move-semantiek
De categorieën lvalue, prvalue en xvalue beschrijven expressies, geen variabelen. Ontdek hoe ze worden gegroepeerd als glvalue en rvalue en hoe ze samenhangen met referenties, overloadkeuze en std::move, dat zelf geen resources overdraagt.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
lvalue: x; prvalue: 42; xvalue: std::move(x); glvalue = lvalue | xvalue; rvalue = prvalue | xvalueElke expressie heeft precies één fundamentele waardecategorie: lvalue, prvalue of xvalue. Een lvalue duidt een object of functie aan en is geen xvalue; een prvalue berekent een waarde of initialiseert een object; een xvalue duidt een object aan waarvan de resources opnieuw kunnen worden gebruikt. glvalue omvat lvalue en xvalue, terwijl rvalue prvalue en xvalue omvat. De categorie hoort bij de expressie, niet bij het type van een variabele; een lvalue hoeft niet wijzigbaar te zijn.
Een expressie x die een gewone variabele aanduidt, is doorgaans een lvalue. In C++23 is die expressie een xvalue als ze een lokale variabele aanduidt en als operand van een return-statement aan de voorwaarden voor een impliciete move voldoet. De expressie 42 is een prvalue en std::move(x) voor een object is een xvalue. Een gedeclareerd type T&& maakt niet elk gebruik van de naam tot een xvalue: in het voorbeeld is rr een lvalue. Wanneer een tijdelijk object nodig is, kan materialisatie van een tijdelijk object een prvalue omzetten in een xvalue die dat object aanduidt.
std::move uit <utility> converteert naar een rvalue-referentie; het kopieert of draagt zelf geen resources over. Het maakt de keuze mogelijk van een move-constructor, meestal T(T&&), in plaats van een copy-constructor T(const T&). Wat er werkelijk gebeurt, hangt af van de gekozen overload. Kopiëren kan nog steeds worden gekozen; std::move behoudt const, waardoor de gebruikelijke constructor T(T&&) geen const-object kan accepteren. De toestand van de bron na een move hangt af van het contract van het type: ga er niet van uit dat het object leeg is.
Het voorbeeld houdt referentiebinding en constructie uit elkaar: het initialiseren van rr drukt niets af, b(rr) kopieert en c(std::move(rr)) kiest de move-constructor. De static_assert-declaraties controleren de categorieën met decltype; de haakjes in decltype((rr)) zijn belangrijk. De constructors drukken alleen berichten af en beheren geen resources. Dit artikel richt zich op C++23; de opgegeven standaard-URL verwijst naar een zich ontwikkelend werkdocument, niet naar een bevroren C++23-publicatie.
Voorbeelden
#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));
}
Resultaat
copy move
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.