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 régions de mémoire principales : la pile (stack) et le tas (heap). Comprendre où résident vos objets est crucial pour écrire un code efficace et sans bogue.

La pile est une mémoire rapide et automatique. Les variables déclarées à l'intérieur des fonctions résident ici 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 tas (heap) est une mémoire plus vaste mais plus lente que vous gérez manuellement. Les objets sur le tas persistent jusqu'à ce que vous les supprimiez 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 :

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

Oublier de libérer 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 pile (stack) et le tas (heap) en construisant une classe Counter simple qui suit la création et la destruction des objets.

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

Counter.h : Définissez une classe Counter avec un attribut privé name (string). Incluez un constructeur qui prend un nom et affiche "Creating: <name>", et un destructeur qui affiche "Destroying: <name>". Ajoutez une méthode getName() pour retourner le nom du compteur.
main.cpp : Démontrez l'allocation sur la pile et sur le tas. Lisez un nom depuis l'entrée, puis :
- Créez un Counter alloué sur la pile en utilisant ce nom
- Créez un Counter alloué sur le tas avec le nom "HeapCounter"
- Affichez les deux noms de compteurs au format "Stack: <name>" et "Heap: <name>"
- Supprimez le compteur alloué sur le tas pour éviter une fuite de mémoire

Observez comment les messages du constructeur et du destructeur apparaissent dans des ordres différents selon le moment où vous créez et supprimez chaque objet. L'objet sur la pile sera automatiquement détruit à la fin de main(), tandis que l'objet sur le tas doit être explicitement supprimé.

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

Aide-mémoire

Les programmes C++ utilisent deux régions de mémoire principales : la pile (stack) et le tas (heap).

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

void example() {
    int x = 10;           // Stack allocation
    Player player;        // Stack allocation - destroyed automatically
}   // x and player are destroyed here

Le tas est une mémoire plus vaste mais plus lente que vous gérez manuellement. Les objets sur le tas persistent jusqu'à ce que vous les supprimiez explicitement :

void example() {
    Player* player = new Player();  // Heap allocation
    // player exists until deleted
    delete player;                   // Manual cleanup required
}

Différences clés :

Pile (Stack)	Tas (Heap)
Allocation rapide	Allocation plus lente
Taille limitée	Grande capacité
Nettoyage automatique	Nettoyage manuel 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 au moment de l'exécution. Oublier de supprimer la mémoire du tas provoque des fuites de mémoire (memory leaks).

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: Afficher le nom du compteur sur la pile au format "Stack: <name>"

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

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

    return 0;
}