CKTIS / C++
Categorías de valor y semántica de movimiento
Las categorías lvalue, prvalue y xvalue describen expresiones, no tipos de variables. Aprende cómo se agrupan en glvalue y rvalue y cómo se relacionan con las referencias, la selección de sobrecargas y std::move, que por sí mismo no transfiere recursos.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
lvalue: x; prvalue: 42; xvalue: std::move(x); glvalue = lvalue | xvalue; rvalue = prvalue | xvalueCada expresión tiene exactamente una categoría de valor fundamental: lvalue, prvalue o xvalue. Un lvalue identifica un objeto o una función y no es un xvalue; un prvalue calcula un valor o inicializa un objeto; un xvalue identifica un objeto cuyos recursos pueden reutilizarse. glvalue incluye lvalue y xvalue, mientras que rvalue incluye prvalue y xvalue. La categoría pertenece a la expresión, no al tipo de una variable; un lvalue no tiene por qué ser modificable.
Una expresión x que nombra una variable ordinaria suele ser un lvalue. En C++23, si nombra una variable local y cumple las condiciones del movimiento implícito como operando de una instrucción return, es un xvalue. La expresión 42 es un prvalue y std::move(x), si x es un objeto, es un xvalue. Que el tipo declarado sea T&& no convierte cada uso del nombre en un xvalue: en el ejemplo, rr es un lvalue. Cuando se necesita un objeto temporal, la materialización de temporales puede convertir un prvalue en un xvalue que designa ese objeto.
std::move de <utility> convierte a una referencia rvalue; por sí mismo no copia ni transfiere recursos. Permite seleccionar un constructor de movimiento, normalmente T(T&&), en lugar de un constructor de copia T(const T&). La acción real depende de la sobrecarga seleccionada. Aun así, puede elegirse la copia; std::move conserva const, por lo que el constructor habitual T(T&&) no puede aceptar un objeto const. El estado de la fuente después del movimiento depende del contrato del tipo: no des por hecho que el objeto queda vacío.
El ejemplo distingue la vinculación de referencias de la construcción: inicializar rr no imprime nada, b(rr) copia y c(std::move(rr)) selecciona el constructor de movimiento. Las declaraciones static_assert comprueban las categorías mediante decltype; los paréntesis de decltype((rr)) son importantes. Los constructores solo imprimen mensajes y no gestionan recursos. Esta entrada se refiere a C++23; la URL del estándar proporcionada lleva a un borrador de trabajo en evolución, no a una publicación definitiva e inmutable de C++23.
Ejemplos
#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));
}
Resultado
copy move
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.