Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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 | xvalue

Cada 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.

Fuentes