Maîtriser la gestion de mémoire en C++ : Utilisation experte de new et delete

Maîtriser la gestion de mémoire en C++ : Utilisation experte de new et delete

Ce guide explique comment allouer et libérer la mémoire heap en C++ avec new et delete, illustré par des exemples clairs et réels.

C++ donne aux développeurs le pouvoir d'allouer de la mémoire à l'exécution — connu sous le nom d'allocation dynamique de mémoire. Contrairement aux langages gérés comme Java ou Python, C++ ne récupère pas automatiquement la mémoire heap ; le programmeur doit explicitement la libérer.

L'utilisation des opérateurs new et delete fournit le mécanisme de base pour cette tâche. Ces opérateurs sont la pierre angulaire de la gestion manuelle de la mémoire en C++ et sont définis dans la bibliothèque standard C++.

---

L'opérateur new

L'opérateur new alloue un bloc de mémoire sur le heap et retourne un pointeur vers son premier octet. Par exemple :

// déclarer un pointeur int
int* pointVar;
// allouer dynamiquement la mémoire en utilisant new
pointVar = new int;
// assigner une valeur à la mémoire allouée
*pointVar = 45;

Dans cet extrait, pointVar reçoit l'adresse d'un int nouvellement alloué. Comme new retourne un pointeur, la variable doit être de type pointeur. Pour les tableaux, new retourne un pointeur vers le premier élément :

int* arr = new int[10]; // arr pointe vers le premier élément d'un tableau de 10 ints

La syntaxe générale est :

variablePointeur = new typeDonnee; // objet unique
variablePointeur = new typeDonnee[taille]; // tableau

---

L'opérateur delete

Quand un objet ou un tableau alloué avec new n'est plus nécessaire, delete doit être appelé pour libérer la mémoire au système d'exploitation. Ne pas le faire entraîne des fuites de mémoire qui peuvent dégrader les performances ou faire planter l'application.

Pour un objet unique :

delete variablePointeur;

Pour un tableau alloué avec new[], utilisez la forme tableau :

delete[] variablePointeur;

Exemple d'un cycle de vie complet :

// allouer un int
int* pointVar = new int;
*pointVar = 45;
cout << *pointVar; // Sortie : 45
// désallouer
delete pointVar;

Astuce : Associez chaque new avec un delete correspondant (ou delete[] pour les tableaux). Utilisez RAII ou les pointeurs intelligents (ex: std::unique_ptr) pour automatiser ce processus en code de production.

---

Exemple 1 : Allocation dynamique de base

#include <iostream>
using namespace std;

int main() {
    int* pointInt;
    float* pointFloat;
    pointInt = new int;
    pointFloat = new float;
    *pointInt = 45;
    *pointFloat = 45.45f;
    cout << *pointInt << endl;
    cout << *pointFloat << endl;
    delete pointInt;
    delete pointFloat;
    return 0;
}

Sortie

45 45.45

Ce programme démontre l'allocation de deux types primitifs, l'assignation, l'affichage et la désallocation propre.

Note : L'allocation dynamique peut améliorer la flexibilité, surtout quand la taille est déterminée à l'exécution.

---

Exemple 2 : Allocation d'un tableau de floats

#include <iostream>
using namespace std;

int main() {
    int num;
    cout << "Entrez le nombre total d'étudiants : ";
    cin >> num;
    float* ptr = new float[num];
    cout << "Entrez la moyenne des étudiants." << endl;
    for (int i = 0; i < num; ++i) {
        cout << "Étudiant" << i + 1 << ": ";
        cin >> *(ptr + i);
    }
    cout << "\nAffichage des moyennes des étudiants." << endl;
    for (int i = 0; i < num; ++i) {
        cout << "Étudiant" << i + 1 << " :" << *(ptr + i) << endl;
    }
    delete[] ptr;
    return 0;
}

Sortie

Entrez le nombre total d'étudiants: 4
Entrez la moyenne des étudiants.
Étudiant1: 3.6
Étudiant2: 3.1
Étudiant3: 3.9
Étudiant4: 2.9
Affichage des moyennes des étudiants.
Étudiant1 :3.6
Étudiant2 :3.1
Étudiant3 :3.9
Étudiant4 :2.9

Le programme demande à l'utilisateur le nombre d'étudiants, alloue un tableau float en conséquence, récupère les entrées, affiche les données et libère enfin la mémoire avec delete[].

---

Exemple 3 : Allocation dynamique d'un objet

#include <iostream>
using namespace std;

class Student {
    int age;
public:
    Student() : age(12) {}
    void getAge() {
        cout << "Âge = " << age << endl;
    }
};

int main() {
    Student* ptr = new Student();
    ptr->getAge();
    delete ptr;
    return 0;
}

Sortie

Âge = 12

Cet exemple crée un objet Student sur le heap. Le constructeur initialise age à 12, et la méthode getAge l'affiche. Après utilisation, delete libère la mémoire de l'objet.

Bonnes pratiques modernes

• Préférez std::make_unique et std::make_shared (C++14/17) à new brut.
• Utilisez des conteneurs standard (std::vector, std::string) au lieu de tableaux bruts.
• Appliquez le principe RAII : acquisition de ressources = initialisation.
• Évitez delete explicite dans le code applicatif ; laissez les destructeurs faire le travail.