Mémoire dynamique (new/delete)

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

Maintenant que vous comprenez les pointeurs et les références, mettons-les en œuvre avec l'allocation dynamique de mémoire. Les opérateurs new et delete vous permettent de créer et de détruire des objets sur le tas (heap) au moment de l'exécution.

Utilisez new pour allouer de la mémoire et obtenir un pointeur vers celle-ci :

int* num = new int;        // Allouer un seul entier
*num = 42;                 // Assigner une valeur via le pointeur

Player* player = new Player("Hero");  // Allouer un objet

Chaque new doit avoir un delete correspondant pour libérer la mémoire :

delete num;      // Libère un objet unique
delete player;   // Appelle le destructeur, puis libère la mémoire

Pour les tableaux, utilisez new[] et delete[] :

int* scores = new int[5];    // Allouer un tableau de 5 entiers
scores[0] = 100;

delete[] scores;             // Libérer le tableau - notez les crochets !

Erreurs courantes à éviter :

// Fuite de mémoire - oubli de delete
int* ptr = new int(10);
ptr = new int(20);    // Perte d'accès à la première allocation !

// Pointeur suspendu - utilisation après delete
delete ptr;
*ptr = 5;             // Comportement indéfini !

// Mauvaise utilisation de delete
int* arr = new int[10];
delete arr;           // Faux ! Devrait être delete[]

Après la suppression, définissez les pointeurs sur nullptr pour éviter une réutilisation accidentelle. La gestion manuelle de la mémoire est source d'erreurs, c'est pourquoi le C++ moderne préfère les pointeurs intelligents, que nous explorerons ensuite.

Défi

Facile

Construisons un système simple de stockage de messages qui démontre l'allocation dynamique de mémoire avec new et delete.

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

MessageBox.h : Définissez une classe MessageBox qui gère dynamiquement un tableau de messages. La classe doit avoir :
- Un pointeur privé vers un tableau de chaînes de caractères (strings) alloué dynamiquement
- Un entier privé suivant le nombre actuel de messages
- Un entier privé stockant la capacité maximale
- Un constructeur qui prend une capacité et alloue le tableau en utilisant new[]
- Un destructeur qui libère correctement la mémoire en utilisant delete[] et affiche "MessageBox destroyed"
- Une méthode addMessage(string msg) qui ajoute un message s'il y a de la place, retournant true en cas de succès ou false s'il est plein
- Une méthode printAll() qui affiche chaque message stocké sur sa propre ligne
main.cpp : Lisez une valeur de capacité et un nombre de messages à partir de l'entrée. Ensuite, lisez ce nombre de chaînes de messages. Créez une MessageBox sur le tas (heap) en utilisant new, ajoutez-y tous les messages, appelez printAll(), puis supprimez correctement la MessageBox pour libérer la mémoire.

Le format d'entrée sera :

Première ligne : la capacité (entier)
Deuxième ligne : le nombre de messages à ajouter (entier)
Lignes suivantes : un message par ligne

Rappel : chaque new nécessite un delete correspondant, et chaque new[] nécessite un delete[] correspondant. Après la suppression, il est de bonne pratique de définir les pointeurs sur nullptr.

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

Aide-mémoire

Utilisez new pour allouer de la mémoire dynamiquement sur le tas (heap) et obtenir un pointeur vers celle-ci :

int* num = new int;        // Allocate single integer
*num = 42;                 // Assign value through pointer

Player* player = new Player("Hero");  // Allocate object

Chaque new doit avoir un delete correspondant pour libérer la mémoire :

delete num;      // Free single object
delete player;   // Calls destructor, then frees memory

Pour les tableaux, utilisez new[] et delete[] :

int* scores = new int[5];    // Allocate array of 5 integers
scores[0] = 100;

delete[] scores;             // Free array - note the brackets!

Erreurs courantes à éviter :

// Memory leak - forgot to delete
int* ptr = new int(10);
ptr = new int(20);    // Lost access to first allocation!

// Dangling pointer - using after delete
delete ptr;
*ptr = 5;             // Undefined behavior!

// Mismatched delete
int* arr = new int[10];
delete arr;           // Wrong! Should be delete[]

Après la suppression, initialisez les pointeurs à nullptr pour éviter une réutilisation accidentelle.

Essayez vous-même

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

int main() {
    int capacity;
    int numMessages;
    
    // Lire la capacité et le nombre de messages
    cin >> capacity;
    cin >> numMessages;
    cin.ignore(); // Effacer le saut de ligne après le nombre
    
    // TODO: Créer un MessageBox sur le tas (heap) en utilisant new
    
    // TODO: Lire et ajouter tous les messages au MessageBox
    for (int i = 0; i < numMessages; i++) {
        string message;
        getline(cin, message);
        // Ajouter le message au MessageBox
    }
    
    // TODO: Appeler printAll() pour afficher tous les messages
    
    // TODO: Supprimer le MessageBox pour libérer la mémoire
    // N'oubliez pas de définir le pointeur à nullptr après la suppression
    
    return 0;
}