Mémoire Pile vs Tas

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

Les programmes C++ utilisent deux grandes régions de mémoire : la pile et le heap. Comprendre où résident vos objets est essentiel pour écrire un code efficace et exempt de bogues.

La stack est une mémoire rapide et automatique. Les variables déclarées à l’intérieur des fonctions y résident et sont automatiquement détruites lorsqu’elles sortent de leur portée.

void example() {
    int x = 10;           // Allocation sur la pile
    Player player;        // Allocation sur la pile - détruit automatiquement
}   // x et player sont détruits ici

Le heap est une mémoire plus grande mais plus lente que vous gérez manuellement. Les objets sur le heap persistent jusqu'à ce que vous les delete explicitement.

void example() {
    Player* player = new Player();  // Allocation sur le tas
    // player existe jusqu'à ce qu'il soit supprimé
    delete player;                   // Nettoyage manuel requis
}

Différences clés :

Pile	Heap
Allocation rapide	Allocation plus lente
Taille limitée	Grande capacité
Nettoyage automatique	Manual cleanup nécessaire
Objets de taille fixe	Objets de taille dynamique

Utilisez l’allocation sur la pile pour les petits objets à courte durée de vie. Utilisez l’allocation sur le tas lorsque les objets doivent survivre à leur portée ou lorsque leur taille est déterminée à l’exécution.

Oublier de supprimer la mémoire du tas provoque des fuites de mémoire, une source courante de bogues dans les programmes C++.

Défi

Facile

Explorons la différence entre la mémoire stack et heap en construisant une simple classe Counter qui suit la manière dont les objets sont créés et détruits.

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

Counter.h : définis une classe Counter avec un attribut name private (chaîne de caractères). Inclus un constructeur qui prend un nom et affiche "Creating: <name>", ainsi qu’un destructeur qui affiche "Destroying: <name>". Ajoute une méthode getName() pour retourner le nom du compteur.
main.cpp : démontre l’allocation sur la stack et dans le heap. Lis un nom depuis l’input, puis :
- Crée un Counter alloué sur la stack en utilisant ce nom
- Crée un Counter alloué dans le heap avec le nom "HeapCounter"
- Affiche les deux noms de compteur au format "Stack: <name>" et "Heap: <name>"
- Supprime le compteur alloué dans le heap pour prevent une fuite de memory

Observe comment les messages du constructeur et du destructeur apparaissent dans des ordres différents selon le moment où tu crées et supprimes chaque objet. L’objet de la stack sera automatiquement détruit lorsque main() se termine, tandis que l’objet du heap doit être supprimé explicitement.

Inclus ton fichier d’en-tête dans main.cpp à l’aide de #include "Counter.h".

Essayez vous-même

#include <iostream>
#include <string>
#include "Counter.h"

using namespace std;

int main() {
    // Lire le nom depuis l'entrée
    string inputName;
    cin >> inputName;

    // TODO: Créer un Counter alloué sur la pile en utilisant inputName

    // TODO: Créer un Counter alloué sur le tas avec le nom "HeapCounter"

    // TODO: Print stack counter name in format "Stack: <name>"

    // TODO: Afficher le nom du compteur heap au format "Heap: <name>"

    // TODO: Supprimer le compteur alloué sur le tas pour éviter une fuite de mémoire

    return 0;
}