O que acontece ao mover um objeto do tipo std::string em C++?

Ao mover um std::string, a propriedade do recurso (memória) é transferida do objeto original para o destino. Em vez de copiar o conteúdo da string (caracteres), apenas o ponteiro para o buffer, seu tamanho e capacidade são copiados. O objeto original fica em um estado válido, mas indefinido (geralmente, o ponteiro torna-se nulo, e o tamanho e a capacidade são zerados), o que impede a liberação dupla de memória. Isso é muito mais rápido do que copiar completamente, especialmente para strings longas.

#include <string>
#include <iostream>
#include <utility>

int main() {
    std::string original = "Uma string muito longa que você não quer copiar";
    std::cout << "Original (antes de mover): " << original << std::endl;

    // Mover original para moved
    std::string moved = std::move(original);

    std::cout << "Movido (após mover): " << moved << std::endl;
    // original agora está em um estado válido, mas indefinido.
    // Tentar usar original após mover sem inicializá-lo é comportamento indefinido.
    // No entanto, muitas implementações o redefinem para um estado vazio.
    // std::cout << "Original (após mover): " << original << std::endl; // Perigoso!

    return 0;
}

Construtor de movimento ou operador de atribuição:

• Atribui o ponteiro para o buffer ao objeto destino.
• Atribui o tamanho e a capacidade ao objeto destino.
• Define o ponteiro do buffer do objeto original como nullptr.
• Define o tamanho e a capacidade do objeto original como 0.

Isso é implementado graças à semântica de movimento (referências rvalue e construtores/operadores especiais).