C++ Academy · Leçon

Bugs courants de mémoire

Éviter les fuites et les pointeurs pendants

Bugs courants de mémoire est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Fuites de mémoire

Une fuite de mémoire se produit lorsque de la mémoire du tas est allouée, mais jamais libérée. Le programme continue de consommer une mémoire à laquelle il ne peut plus accéder.

void leak() {
    int* p = new int(5);
    // missing delete p;  -> leaked
}

Pointeurs pendants

Un pointeur pendant pointe vers une mémoire qui a déjà été libérée. Le déréférencer produit un comportement indéfini.

int* p = new int(7);
delete p;
// *p = 3;   // BUG: dangling access

Double libération

Appeler delete deux fois sur le même pointeur corrompt le tas et fait souvent planter le programme.

int* p = new int(1);
delete p;
// delete p;   // BUG: double free

Utilisation après libération

Lire ou écrire via un pointeur après la suppression de l'objet constitue une utilisation après libération, une source fréquente de vulnérabilités de sécurité.

Dépassement de tampon

Écrire au-delà de la fin d'un tableau écrase une mémoire sans rapport. Respectez toujours les limites.

int a[3] = {1, 2, 3};
// a[3] = 99;   // BUG: out of bounds

delete incompatible

Utiliser delete sur une allocation effectuée avec new[], ou inversement, produit un comportement indéfini. Utilisez-les toujours par paire.

int* arr = new int[4];
// delete arr;   // BUG: should be delete[] arr;
delete[] arr;     // correct

Pointeurs non initialisés

Un pointeur non initialisé contient une valeur indéterminée. Initialisez-le toujours avec une adresse valide ou nullptr.

#include <iostream>

int main() {
    int* p = nullptr;   // safe default
    if (!p) std::cout << "not set\n";
}

Renvoyer des adresses locales

Renvoyer l'adresse d'une variable locale de la pile crée immédiatement un pointeur pendant, puisque cette variable disparaît au retour.

int* bad() {
    int x = 10;
    return &x;   // BUG: x is gone
}

Les pointeurs intelligents empêchent les fuites

Remplacer les propriétaires bruts par std::unique_ptr élimine la plupart des fuites et des doubles libérations : le nettoyage est automatique et n'a lieu qu'une seule fois.

#include <iostream>
#include <memory>

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

Outils pour détecter les bogues

Des outils comme AddressSanitizer et Valgrind détectent à l'exécution les fuites, les doubles libérations et les accès hors limites. Intégrez-les à vos tests.

La prévention vaut mieux que la détection

La meilleure solution consiste à éviter entièrement la possession brute : utilisez des conteneurs comme std::vector et des pointeurs intelligents afin que la bibliothèque gère correctement la mémoire à votre place.

Vérification rapide

Testez votre compréhension des bogues de mémoire.

Récapitulatif

Vous avez découvert les bogues de mémoire classiques : fuites, pointeurs pendants, double libération, utilisation après libération, dépassements de tampon et delete incompatible. Prévenez-les avec des pointeurs intelligents et des conteneurs, puis détectez les autres avec des outils de détection comme AddressSanitizer et Valgrind.

Questions Fréquemment Posées

La leçon « Bugs courants de mémoire » est-elle gratuite ?

Oui — le texte complet de « Bugs courants de mémoire » 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 « Bugs courants de mémoire » ?

Éviter les fuites et les pointeurs pendants 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 4 sur 4.

Combien de temps prend la leçon « Bugs courants de mémoire » ?

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