Constructeur de copie

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

Un constructeur par copie crée un nouvel objet en tant que copie d'un objet existant. Il est appelé lorsque vous initialisez un objet à partir d'un autre objet du même type, passez un objet par valeur ou retournez un objet par valeur.

Le constructeur de recopie prend une référence constante vers un objet de la même classe :

class Player {
    std::string name;
    int health;
public:
    Player(std::string n, int h) : name(n), health(h) {}
    
    // Constructeur de recopie
    Player(const Player& other) {
        name = other.name;
        health = other.health;
    }
};

Player original("Hero", 100);
Player copy = original;    // Constructeur de recopie appelé
Player another(original);  // Appelle également le constructeur de recopie

Si vous ne définissez pas de constructeur de recopie, le compilateur en génère un qui effectue une copie superficielle - il copie directement la valeur de chaque membre. Cela fonctionne bien pour les types simples, mais pose des problèmes lorsque votre classe gère de la mémoire dynamique.

class Buffer {
    int* data;
    size_t size;
public:
    Buffer(size_t s) : size(s) {
        data = new int[size];
    }
    
    // Constructeur de copie profonde
    Buffer(const Buffer& other) : size(other.size) {
        data = new int[size];              // Allouer de la nouvelle mémoire
        for (size_t i = 0; i < size; i++)
            data[i] = other.data[i];       // Copier le contenu
    }
    
    ~Buffer() { delete[] data; }
};

Sans constructeur de recopie personnalisé, les deux objets pointeraient vers la même mémoire. Lorsqu'un objet est détruit, l'autre se retrouverait avec un pointeur suspendu. Une copie profonde alloue une nouvelle mémoire et copie les données réelles, garantissant que chaque objet possède ses propres ressources.

Défi

Facile

Construisons un système d'historique de messages qui démontre l'importance de la copie profonde (deep copy) lorsque votre classe gère de la mémoire dynamique. Vous allez créer une classe MessageLog qui stocke des messages dans un tableau alloué dynamiquement, et implémenter un constructeur de copie approprié pour garantir que chaque copie possède sa propre mémoire indépendante.

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

MessageLog.h : Définissez une classe MessageLog qui gère une collection de messages en utilisant la mémoire dynamique. Votre classe doit avoir :
- Membres privés : un pointeur vers un tableau de chaînes de caractères (string) pour stocker les messages, une capacity pour le nombre maximum de messages, et un count pour le nombre actuel de messages
- Un constructeur paramétré qui prend une capacité, alloue le tableau sur le tas (heap) et initialise count à 0
- Un constructeur de copie qui effectue une copie profonde — en allouant une nouvelle mémoire et en copiant tous les messages de l'objet source
- Un destructeur qui libère la mémoire allouée et affiche "MessageLog destroyed"
- Une méthode addMessage(string msg) qui ajoute un message s'il y a de la place
- Une méthode getCount() qui retourne le nombre actuel de messages
- Une méthode getMessage(int index) qui retourne le message à l'index donné
main.cpp : Démontrez que votre constructeur de copie crée une copie indépendante. Lisez une valeur de capacité et deux messages à partir de l'entrée, puis :
- Créez un MessageLog nommé original avec la capacité saisie
- Ajoutez les deux messages à original
- Créez une copie nommée backup en utilisant le constructeur de copie
- Ajoutez un troisième message "New message" à original uniquement
- Affichez "Original count: <count>"
- Affichez "Backup count: <count>"
- Affichez tous les messages de backup, un par ligne

Le format d'entrée sera :

Première ligne : capacité (entier)
Deuxième ligne : premier message (chaîne de caractères)
Troisième ligne : deuxième message (chaîne de caractères)

Si votre copie profonde est implémentée correctement, le backup devrait avoir 2 messages alors que l'original en a 3 — prouvant qu'ils ont une mémoire indépendante. Sans un constructeur de copie approprié, les deux partageraient le même tableau et les modifications apportées à l'un affecteraient l'autre !

Incluez votre fichier d'en-tête dans main.cpp en utilisant #include "MessageLog.h".

Aide-mémoire

Un constructeur de recopie crée un nouvel objet en tant que copie d'un objet existant. Il prend une référence constante vers un objet de la même classe :

class Player {
    std::string name;
    int health;
public:
    Player(std::string n, int h) : name(n), health(h) {}
    
    // Constructeur de recopie
    Player(const Player& other) {
        name = other.name;
        health = other.health;
    }
};

Player original("Hero", 100);
Player copy = original;    // Constructeur de recopie appelé
Player another(original);  // Appelle également le constructeur de recopie

Si vous ne définissez pas de constructeur de recopie, le compilateur en génère un qui effectue une copie superficielle (shallow copy) - en copiant directement la valeur de chaque membre. Cela pose des problèmes lorsque votre classe gère de la mémoire dynamique.

Un constructeur de copie profonde (deep copy) alloue de la nouvelle mémoire et copie les données réelles, garantissant que chaque objet possède ses propres ressources :

class Buffer {
    int* data;
    size_t size;
public:
    Buffer(size_t s) : size(s) {
        data = new int[size];
    }
    
    // Constructeur de copie profonde
    Buffer(const Buffer& other) : size(other.size) {
        data = new int[size];              // Allouer de la nouvelle mémoire
        for (size_t i = 0; i < size; i++)
            data[i] = other.data[i];       // Copier le contenu
    }
    
    ~Buffer() { delete[] data; }
};

Sans constructeur de recopie personnalisé, les deux objets pointeraient vers la même zone mémoire, provoquant des pointeurs suspendus (dangling pointers) lorsque l'un d'eux est détruit.

Essayez vous-même

#include <iostream>
#include <string>
#include "MessageLog.h"
using namespace std;

int main() {
    // Lire l'entrée
    int capacity;
    cin >> capacity;
    cin.ignore();
    
    string msg1, msg2;
    getline(cin, msg1);
    getline(cin, msg2);

    // TODO: Créer un MessageLog nommé 'original' avec la capacité saisie

    // TODO: Ajouter les deux messages à original

    // TODO: Créer une copie nommée 'backup' en utilisant le constructeur par recopie

    // TODO: Ajouter "New message" à original uniquement

    // TODO: Afficher "Original count: <count>"

    // TODO: Afficher "Backup count: <count>"

    // TODO: Afficher tous les messages de backup, un par ligne

    return 0;
}