Mémoire de pile ou de 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 tas. Comprendre où résident vos objets est essentiel pour écrire un code efficace et exempt de bugs.

La pile 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 tas est une mémoire plus grande, mais plus lente, que vous gérez manuellement. Les objets dans 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 :

Pile	Tas
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 à 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 de la pile et celle du tas en créant une simple classe Counter 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 (chaîne de caractères). Incluez un constructeur qui prend un nom et affiche "Creating: <name>", ainsi qu'un destructeur qui affiche "Destroying: <name>". Ajoutez une méthode getName() pour renvoyer le nom du compteur.
main.cpp : illustrez 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 l'ordre dans lequel les messages du constructeur et du destructeur apparaissent, qui varie selon le moment où vous créez et supprimez chaque objet. L'objet sur la pile sera automatiquement détruit lorsque main() se termine, tandis que l'objet sur le tas doit être supprimé explicitement.

Incluez votre 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;
}