Constructeur de copie

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

Un constructeur de copie crée un nouvel objet comme copie d’un objet existant. Il est appelé lorsque vous initialisez un objet à partir d’un autre objet du même type, transmettez un objet par valeur ou retournez un objet par valeur.

Le constructeur de copie prend une référence const 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 copie
    Player(const Player& other) {
        name = other.name;
        health = other.health;
    }
};

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

Si vous ne définissez pas de constructeur de copie, 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 cause 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 une 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 copie personnalisé, les deux objets pointeraient vers la même mémoire. Lorsque l’un est détruit, l’autre aurait un pointeur suspendu. Une copie en profondeur 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 des messages qui démontre l'importance de la copie profonde lorsque votre classe gère de la mémoire dynamique. Vous allez créer une classe MessageLog qui stocke les messages dans un tableau alloué dynamiquement et implémenter un constructeur de copie approprié afin de 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éfinir une classe MessageLog qui gère une collection de messages à l'aide de mémoire dynamique. Votre classe doit comporter :
- Des membres privés : un pointeur vers un tableau de chaînes de caractères pour stocker les messages, une capacity correspondant au nombre maximal de messages et un count correspondant au nombre actuel de messages
- Un constructeur paramétré qui accepte une capacité, alloue le tableau sur le tas et initialise count à 0
- Un constructeur de copie qui effectue une copie profonde : il alloue une nouvelle zone mémoire et copie tous les messages depuis 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 reste de la place
- Une méthode getCount() qui renvoie le nombre actuel de messages
- Une méthode getMessage(int index) qui renvoie le message à l'index indiqué
main.cpp : démontrer que votre constructeur de copie crée une copie indépendante. Lire une valeur de capacité et deux messages en entrée, puis :
- Créer un MessageLog appelé original avec la capacité fournie en entrée
- Ajouter les deux messages à original
- Créer une copie appelée backup à l'aide du constructeur de copie
- Ajouter un troisième message "New message" uniquement à original
- Afficher "Original count: <count>"
- Afficher "Backup count: <count>"
- Afficher tous les messages de backup, un par ligne

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

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 correctement implémentée, la sauvegarde doit contenir 2 messages tandis que l'original en contient 3 : cela prouve qu'ils disposent d'une mémoire indépendante. Sans 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 à l'aide de #include "MessageLog.h".

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 appelé 'original' avec la capacité d'entrée

    // TODO: Ajouter les deux messages à original

    // TODO: Créer une copie appelée 'backup' en utilisant le constructeur de copie

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

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

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

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

    return 0;
}