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 en copiant 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 renvoyez un objet par valeur.

Le constructeur de copie prend une référence constante vers un objet de la même classe. Il doit s’agir d’une référence : passer other par valeur nécessiterait lui-même une copie, ce qui appellerait le constructeur de copie encore et encore, à l’infini. Elle est const, car effectuer une copie ne devrait jamais modifier l’original :

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 tu ne définis 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 pose des problèmes lorsque ta 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 zone 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 zone mémoire. Lorsque l’un est détruit, l’autre aurait un pointeur pendant. Une copie profonde alloue une nouvelle zone mémoire et copie les données réelles, garantissant que chaque objet possède ses propres ressources.

Défi

Facile

Créons un système d’historique des messages qui montre l’importance d’une copie profonde lorsque ta classe gère de la mémoire dynamique. Tu vas créer une classe MessageLog qui stocke des messages dans un tableau alloué dynamiquement et implémenter un constructeur de copie adéquat pour que chaque copie dispose de sa propre mémoire indépendante.

Tu vas créer deux fichiers pour organiser ton code :

MessageLog.h : définis une classe MessageLog qui gère une collection de messages à l’aide de mémoire dynamique. Ta 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 prend une capacité, alloue le tableau sur le tas et initialise le nombre à 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 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 donné
main.cpp : montre que ton constructeur de copie crée une copie indépendante. Lis une valeur de capacité et deux messages depuis l’entrée, puis :
- Crée un MessageLog appelé original avec la capacité saisie
- Ajoute les deux messages à original
- Crée une copie appelée backup à l’aide du constructeur de copie
- Ajoute un troisième message "New message" à original uniquement
- Affiche "Original count: <count>"
- Affiche "Backup count: <count>"
- Affiche tous les messages de backup, un par ligne

Le format d’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 ta copie profonde est correctement implémentée, la sauvegarde devrait 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 adéquat, les deux partageraient le même tableau et les modifications apportées à l’un affecteraient l’autre !

Inclus ton fichier d’en-tête dans main.cpp avec #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 nommé 'original' avec la capacité saisie

    // TODO: Ajouter les deux messages à original

    // TODO: Créer une copie nommée 'backup' à l'aide du constructeur de copie

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

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

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

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

    return 0;
}