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 des 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 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; }
};

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 montre comment les constructeurs de déplacement transfèrent efficacement la propriété des ressources. Vous allez créer une classe DataPacket qui gère un tableau de bytes alloué dynamiquement, et implémenter un constructeur de déplacement qui « vole » les données au lieu de les copier.

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

DataPacket.h : définir une classe DataPacket qui gère une charge utile de données entières. Votre classe doit avoir :
- Membres privés : un pointeur vers un tableau d’entiers (payload), une size correspondant au nombre d’éléments, et un packetId (chaîne de caractères) 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 allant de 0 à size-1. Afficher "Packet <id> created with size <size>"
- Un constructeur de déplacement marqué noexcept qui transfère la propriété de la charge utile depuis l’objet source. Afficher "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 renvoie la taille actuelle
- Une méthode getId() qui renvoie l’ID du paquet
- Une méthode getSum() qui renvoie la somme de tous les éléments de la charge utile (renvoyer 0 si payload est nul)
main.cpp : démontrer la construction par déplacement en lisant un ID de paquet et une taille depuis l’entrée. Ensuite :
- Créer un DataPacket appelé original avec les valeurs saisies
- Afficher "Original - ID: <id>, Size: <size>, Sum: <sum>"
- Créer un nouveau paquet appelé transferred en effectuant un déplacement depuis original à l’aide de std::move()
- Afficher "After move:"
- Afficher "Original - ID: <id>, Size: <size>, Sum: <sum>"
- Afficher "Transferred - ID: <id>, Size: <size>, Sum: <sum>"

Le format de l’entrée sera le suivant :

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

Après le déplacement, le paquet original doit 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é doit contenir toutes les données d’origine. Cela montre comment la sémantique de déplacement é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 à l’aide de #include "DataPacket.h" et n’oubliez pas d’inclure <utility> pour std::move().

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 depuis original
    // Conseil : 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;
}