Constructeur de déplacement

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy — leçon 21 sur 104.

Un constructeur de déplacement transfère les ressources d'un objet temporaire au lieu de les copier. Alors qu'un constructeur de copie duplique les données, un constructeur de déplacement « vole » les ressources, laissant l'objet source dans un état valide mais vide. Cela évite les copies profondes coûteuses lorsque l'objet source est de toute façon sur le point d'être détruit.

Le constructeur de mouvement prend une référence rvalue, notée par && :

class Buffer {
    int* data;
    size_t size;
public:
    Buffer(size_t s) : size(s), data(new int[s]) {}
    
    // Constructeur de mouvement
    Buffer(Buffer&& other) noexcept {
        data = other.data;       // Voler le pointeur
        size = other.size;
        other.data = nullptr;    // Laisser la source dans un état valide
        other.size = 0;
    }
    
    ~Buffer() { delete[] data; }
};

La différence clé par rapport à la copie : nous n'allouons pas de nouvelle mémoire. Nous prenons simplement la propriété de la mémoire existante et définissons le pointeur de la source sur nullptr afin que son destructeur ne supprime pas nos données.

Les constructeurs de déplacement sont appelés lors de l'initialisation à partir d'objets temporaires ou lors de l'utilisation de std::move() :

Buffer createBuffer() {
    return Buffer(1000);    // Constructeur de déplacement utilisé (valeur de retour)
}

Buffer b1(1000);
Buffer b2(std::move(b1));   // Déplacement explicite - b1 est maintenant vide

Marquez les constructeurs de déplacement comme noexcept lorsque cela est possible. Cela indique au compilateur que l'opération ne lèvera pas d'exceptions, permettant des optimisations importantes dans les conteneurs comme std::vector.

Défi

Facile

Construisons un système de paquets de données qui démontre comment les constructeurs de mouvement transfèrent efficacement la propriété des ressources. Vous allez créer une classe DataPacket qui gère un tableau d'octets alloué dynamiquement, et implémenter un constructeur de mouvement qui « vole » les données au lieu de les copier.

Vous allez créer deux fichiers pour organiser votre code :

DataPacket.h : Définissez une classe DataPacket qui gère une charge utile (payload) de données entières. Votre classe doit avoir :
- Membres privés : un pointeur vers un tableau d'entiers (payload), une taille (size) pour le nombre d'éléments, et un packetId (string) pour identifier le paquet
- Un constructeur paramétré qui prend un ID de paquet et une taille, alloue le tableau et le remplit avec des valeurs de 0 à size-1. Affichez "Packet <id> created with size <size>"
- Un constructeur de mouvement marqué noexcept qui transfère la propriété de la charge utile depuis l'objet source. Affichez "Packet <id> moved". N'oubliez pas de laisser la source dans un état vide valide (nullptr, size 0)
- Un destructeur qui libère la mémoire si le pointeur n'est pas nul, et affiche "Packet <id> destroyed"
- Une méthode getSize() qui retourne la taille actuelle
- Une méthode getId() qui retourne l'ID du paquet
- Une méthode getSum() qui retourne la somme de tous les éléments de la charge utile (retourne 0 si payload est nul)
main.cpp : Démontrez la construction par mouvement en lisant un ID de paquet et une taille depuis l'entrée. Ensuite :
- Créez un DataPacket nommé original avec les valeurs d'entrée
- Affichez "Original - ID: <id>, Size: <size>, Sum: <sum>"
- Créez un nouveau paquet nommé transferred en déplaçant original à l'aide de std::move()
- Affichez "After move:"
- Affichez "Original - ID: <id>, Size: <size>, Sum: <sum>"
- Affichez "Transferred - ID: <id>, Size: <size>, Sum: <sum>"

Le format d'entrée sera :

Première ligne : ID du paquet (chaîne de caractères)
Deuxième ligne : taille (entier)

Après le mouvement, le paquet original devrait avoir une taille de 0 et une somme de 0 (puisque ses données ont été transférées), tandis que le paquet transféré devrait avoir toutes les données originales. Cela démontre comment la sémantique de mouvement évite les copies profondes coûteuses en transférant simplement la propriété du pointeur.

Incluez votre fichier d'en-tête dans main.cpp en utilisant #include "DataPacket.h" et n'oubliez pas d'inclure <utility> pour std::move().

Aide-mémoire

Un constructeur de déplacement transfère les ressources d'un objet temporaire au lieu de les copier, évitant ainsi des copies profondes coûteuses. Il prend une référence rvalue (&&) et « vole » les ressources, laissant l'objet source dans un état valide mais vide.

class Buffer {
    int* data;
    size_t size;
public:
    Buffer(size_t s) : size(s), data(new int[s]) {}
    
    // Constructeur de déplacement
    Buffer(Buffer&& other) noexcept {
        data = other.data;       // Voler le pointeur
        size = other.size;
        other.data = nullptr;    // Laisser la source dans un état valide
        other.size = 0;
    }
    
    ~Buffer() { delete[] data; }
};

Les constructeurs de déplacement sont appelés lors de l'initialisation à partir d'objets temporaires ou lors de l'utilisation de std::move() :

Buffer createBuffer() {
    return Buffer(1000);    // Constructeur de déplacement utilisé (valeur de retour)
}

Buffer b1(1000);
Buffer b2(std::move(b1));   // Déplacement explicite - b1 est maintenant vide

Marquez les constructeurs de déplacement comme noexcept lorsque cela est possible pour permettre des optimisations dans les conteneurs standards.

Essayez vous-même

#include <iostream>
#include <string>
#include <utility>
#include "DataPacket.h"

using namespace std;

int main() {
    // Lire l'entrée
    string packetId;
    int size;
    cin >> packetId;
    cin >> size;

    // TODO: Créer un DataPacket nommé 'original' avec les valeurs d'entrée

    // TODO: Afficher "Original - ID: <id>, Size: <size>, Sum: <sum>"

    // TODO: Créer un nouveau paquet nommé 'transferred' en déplaçant original
    // Hint: Utiliser std::move()

    // TODO: Afficher "After move:"

    // TODO: Afficher "Original - ID: <id>, Size: <size>, Sum: <sum>"

    // TODO: Afficher "Transferred - ID: <id>, Size: <size>, Sum: <sum>"

    return 0;
}