C++ Academy · Leçon

Allocation sur le tas avec new/delete

Gérer la mémoire dynamique

Allocation sur le tas avec new/delete est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Mémoire dynamique avec new

L'opérateur new alloue un objet sur le tas (mémoire libre) et renvoie un pointeur vers celui-ci. Les objets du tas restent en mémoire jusqu'à ce que vous les libériez explicitement.

#include <iostream>

int main() {
    int* p = new int(42);   // heap allocation
    std::cout << *p << "\n";
    delete p;               // release it
}

Libérer avec delete

Chaque new doit correspondre à exactement un delete. L'oublier provoque une fuite de mémoire ; l'utiliser deux fois corrompt le tas.

#include <iostream>

int main() {
    double* d = new double(3.5);
    std::cout << *d << "\n";
    delete d;     // exactly once
}

Tableaux : new[] et delete[]

Pour les tableaux, utilisez new[] et le delete[] correspondant. Mélanger new[] avec un simple delete produit un comportement indéfini.

#include <iostream>

int main() {
    int* arr = new int[3]{1, 2, 3};
    for (int i = 0; i < 3; ++i) std::cout << arr[i] << "\n";
    delete[] arr;   // note the [ ]
}

Pourquoi utiliser le tas

Utilisez le tas lorsqu'un objet doit survivre à la fonction qui l'a créé, ou lorsque sa taille n'est connue qu'à l'exécution. Dans les autres cas, préférez la pile.

La durée de vie du tas est gérée manuellement

Contrairement à la pile, le tas ne libère pas automatiquement les objets. Vous contrôlez précisément le moment où la mémoire est libérée, et cette responsabilité vous incombe.

#include <iostream>

int* makeCounter() {
    return new int(0);   // survives the function
}

int main() {
    int* c = makeCounter();
    std::cout << *c << "\n";
    delete c;
}

Définir les pointeurs sur nullptr après delete

Après une suppression, définissez le pointeur sur nullptr afin qu'une réutilisation accidentelle échoue clairement au lieu d'accéder à une mémoire déjà libérée.

#include <iostream>

int main() {
    int* p = new int(9);
    delete p;
    p = nullptr;     // now p is safe to check
    if (!p) std::cout << "freed\n";
}

L'allocation peut échouer

Si le système manque de mémoire, new lève std::bad_alloc. Pour les allocations très volumineuses, cette situation est tout à fait possible.

Tampons dont la taille est déterminée à l'exécution

Les tableaux du tas peuvent utiliser une taille calculée à l'exécution, ce que les tableaux de la pile ne permettent pas de faire de manière portable.

#include <iostream>

int main() {
    int n = 5;
    int* buf = new int[n];
    for (int i = 0; i < n; ++i) buf[i] = i * i;
    std::cout << buf[4] << "\n";
    delete[] buf;
}

Préférez les pointeurs intelligents

Le C++ moderne évite les new/delete bruts. std::unique_ptr et std::make_unique libèrent automatiquement la mémoire lorsque le pointeur sort de sa portée.

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_unique<int>(42);
    std::cout << *p << "\n";
}   // freed automatically

Le coût du tas

L'allocation sur le tas est plus lente que sur la pile : elle recherche un bloc libre et met à jour les informations de gestion. Des allocations fréquentes de très petite taille peuvent nuire aux performances.

Associez chaque new

La règle d'or : chaque new nécessite un delete, et chaque new[] nécessite un delete[]. Mieux encore, laissez les pointeurs intelligents s'en charger.

Vérification rapide

Testez votre compréhension de l'allocation sur le tas.

Récapitulatif

Vous avez appris à allouer sur le tas avec new/new[] et à libérer avec delete/delete[]. Les objets du tas survivent à leur portée, mais nécessitent un nettoyage manuel. Faites correspondre chaque allocation, définissez les pointeurs libérés sur null et préférez std::unique_ptr dans le code moderne.

Questions Fréquemment Posées

La leçon « Allocation sur le tas avec new/delete » est-elle gratuite ?

Oui — le texte complet de « Allocation sur le tas avec new/delete » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Allocation sur le tas avec new/delete » ?

Gérer la mémoire dynamique Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Allocation sur le tas avec new/delete » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy