Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Categorias de valor e semântica de movimentação

As categorias lvalue, prvalue e xvalue descrevem expressões, não tipos de variáveis. Aprende como se agrupam em glvalue e rvalue e como se relacionam com referências, seleção de sobrecargas e std::move, que por si só não transfere recursos.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

lvalue: x; prvalue: 42; xvalue: std::move(x); glvalue = lvalue | xvalue; rvalue = prvalue | xvalue

Cada expressão tem exatamente uma categoria de valor fundamental: lvalue, prvalue ou xvalue. Um lvalue identifica um objeto ou uma função e não é um xvalue; um prvalue calcula um valor ou inicializa um objeto; um xvalue identifica um objeto cujos recursos podem ser reutilizados. glvalue inclui lvalue e xvalue, enquanto rvalue inclui prvalue e xvalue. A categoria pertence à expressão, não ao tipo de uma variável; um lvalue não tem de ser modificável.

Uma expressão x que designa uma variável comum é normalmente um lvalue. Em C++23, se designar uma variável local e cumprir as condições para a movimentação implícita enquanto operando de uma instrução return, é um xvalue. A expressão 42 é um prvalue e std::move(x), quando x é um objeto, é um xvalue. Um tipo declarado T&& não transforma cada utilização do nome num xvalue: no exemplo, rr é um lvalue. Quando é necessário um objeto temporário, a materialização de temporários pode converter um prvalue num xvalue que designa esse objeto.

std::move de <utility> converte para uma referência rvalue; por si só, não copia nem transfere recursos. Permite selecionar um construtor de movimentação, normalmente T(T&&), em vez de um construtor de cópia T(const T&). A ação efetiva depende da sobrecarga selecionada. Ainda pode ser selecionada a cópia; std::move preserva const, pelo que o construtor habitual T(T&&) não pode aceitar um objeto const. O estado da origem após a movimentação depende do contrato do tipo — não presumas que o objeto fica vazio.

O exemplo distingue a ligação de uma referência da construção: inicializar rr não imprime nada, b(rr) copia e c(std::move(rr)) seleciona o construtor de movimentação. As declarações static_assert verificam as categorias através de decltype; os parênteses em decltype((rr)) são importantes. Os construtores apenas imprimem mensagens e não gerem recursos. Esta entrada refere-se a C++23; o URL do padrão fornecido aponta para um projeto em evolução, não para uma publicação C++23 definitiva e imutável.

Exemplos

#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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes