Que se passe-t-il lors du déplacement d'un objet de type std::string en C++?

Lors du déplacement d'un std::string, la propriété de la ressource (mémoire) est transférée de l'objet source à l'objet cible. Au lieu de copier le contenu de la chaîne (les caractères), seul le pointeur vers le buffer, sa taille et sa capacité sont copiés. L'objet source est alors dans un état valide mais indéfini (généralement, le pointeur devient nul, et la taille et la capacité sont réinitialisées à zéro), ce qui empêche la double libération de mémoire. Cela est beaucoup plus rapide que la copie complète, surtout pour les longues chaînes.

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

int main() {
    std::string original = "Une chaîne très longue que vous ne voulez pas copier";
    std::cout << "Original (avant déplacement): " << original << std::endl;

    // Déplacer original vers moved
    std::string moved = std::move(original);

    std::cout << "Déplacé (après déplacement): " << moved << std::endl;
    // original est maintenant dans un état valide mais indéfini.
    // Tenter d'utiliser original après déplacement sans l'initialiser est un comportement indéfini.
    // Cependant, souvent l'implémentation le remet dans un état vide.
    // std::cout << "Original (après déplacement): " << original << std::endl; // Dangereux!

    return 0;
}

Constructeur de déplacement ou opérateur d'assignation:

• Attribue le pointeur vers le buffer à l'objet cible.
• Attribue la taille et la capacité à l'objet cible.
• Définit le pointeur du buffer de l'objet source à nullptr.
• Définit la taille et la capacité de l'objet source à 0.

Cela est réalisé grâce à la sémantique de déplacement (références rvalue et constructeurs/opérateurs spéciaux).