Capítulo 12: Move Semantics, Rvalues e o Operador Nave Espacial (<=>)

Especialização em Sistemas com C++ • C++20 & C++23 • RAII, Smart Pointers, Templates, Concorrência e Alta Performance

🗺️ Mapa Conceitual de Semântica de Movimento e Operador Spaceship

flowchart TD
    Inovacao["Modernizações de Linguagem"] --> MoveSemantics["Move Semantics (Semântica de Movimento)"]
    Inovacao --> Spaceship["Operador Nave Espacial <=> (C++20)"]

    subgraph MOVE_DETAILS["Mecânica de Rvalues (&&)"]
        Lvalue["Lvalues (Objetos com Identidade / Endereço Persistente)"]
        Rvalue["Rvalues (Temporários Descartáveis / Resultados de Expressão)"]
        StdMove["std::move() (Cast Explícito para Rvalue Reference)"]
        Theft["Roubo Eficiente de Recursos O(1) Sem Alocação"]
    end

    subgraph SPACESHIP_DETAILS["Three-Way Comparison (<=>)"]
        Ordering["std::strong_ordering / std::weak_ordering"]
        Synthesize["Sintetização Automática dos 6 Operadores (==, !=, <, <=, >, >=)"]
    end

    MoveSemantics --> MOVE_DETAILS
    Spaceship --> SPACESHIP_DETAILS

    style Inovacao fill:#e1f5fe,stroke:#03a9f4,stroke-width:2px
    style MOVE_DETAILS fill:#ede7f6,stroke:#7e57c2,stroke-width:2px
    style SPACESHIP_DETAILS fill:#fff3e0,stroke:#ff9800,stroke-width:2px

🏛️ 1. O Problema Histórico da Cópia Profunda e o Advento de Rvalues

Antes do C++11, passar ou retornar objetos pesados (como um std::vector contendo 1 milhão de elementos) implicava em cópias profundas caras (deep copies). Cada elemento precisava ser realocado e duplicado no Heap, gerando lentidão crônica em sistemas que processam grandes volumes de dados.

A Move Semantics resolveu esse dilema distinguindo o ciclo de vida dos valores:

Lvalues (T&): Objetos que possuem identidade e endereço fixo na memória (você pode obter seu endereço com &obj).
Rvalues (T&&): Valores temporários que estão prestes a ser destruídos (como o retorno de uma função ou uma expressão aritmética a + b).

Em vez de copiar dados de um rvalue, o objeto de destino pode simplesmente “roubar” os ponteiros internos do doador em tempo constante $O(1)$, deixando o objeto de origem em um estado vazio, mas válido.

⚙️ 2. `std::move`: O Que Ele Realmente Faz?

Um equívoco comum entre iniciantes é pensar que std::move move qualquer dado por si mesmo. Na verdade, std::move não emite nenhuma instrução de CPU e não move um único byte.

std::move é apenas um cast incondicional de tipo em tempo de compilação: ele converte uma expressão do tipo lvalue para uma referência a rvalue (static_cast<std::remove_reference_t<T>&&>(t)), sinalizando ao compilador que é permitido despachar para o construtor de movimento (Move Constructor).

#include <vector>
#include <utility>

std::vector<int> coletar_dados() {
    std::vector<int> buffer(100'000, 42);
    return buffer; // RVO (Return Value Optimization) ou Move automático O(1)
}

void processar() {
    std::vector<int> fonte = coletar_dados();
    // Rouba o buffer interno da fonte sem copiar nenhum elemento!
    std::vector<int> destino = std::move(fonte); 
}

📦 3. O Operador Nave Espacial `<=>` do C++20

Antes do C++20, para tornar uma classe comparável de forma completa, o programador era obrigado a sobrecarregar manualmente 6 operadores relacionais: ==, !=, <, <=, >, >=. Isso gerava centenas de linhas de código repetitivo e sujeito a inconsistências lógicas.

No C++20, foi introduzido o Operador de Comparação de Três Vias (Three-Way Comparison), informalmente chamado de Spaceship Operator (<=>):

#include <compare>

struct MetricasHardware {
    int cpu_usage;
    int ram_usage;
    double temperatura;

    // Uma única linha sintetiza perfeitamente os 6 operadores de comparação!
    auto operator<=>(const MetricasHardware&) const = default;
};

Categorias de Ordenação:

std::strong_ordering: Equivalência total (se a == b, então f(a) == f(b) para qualquer propriedade observável, comum para números inteiros).
std::weak_ordering: Dois objetos podem ser considerados equivalentes sem serem estritamente indistinguíveis (ex: comparação de strings sem distinção de maiúsculas e minúsculas).
std::partial_ordering: Alguns valores não podem ser comparados entre si (ex: números em ponto flutuante contendo NaN).

📊 4. Matriz Comparativa: Cópia vs Movimento

Critério de Avaliação	Construtor de Cópia (`const T&`)	Construtor de Movimento (`T&&`)
Complexidade de Tempo	Linear $O(N)$ em relação aos dados	Constante $O(1)$
Alocação de Memória	Sim, aloca novos blocos no Heap	Não, transfere ponteiros existentes
Estado do Objeto Doador	Permanece inalterado	Fica esvaziado (válido para destruição)
Garantia de Exceção	Pode lançar `std::bad_alloc`	Geralmente marcado como `noexcept`