C Academy · Leçon

Fuites de mémoire

Trouvez et évitez les fuites

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

Qu’est-ce qu’une fuite mémoire

Une fuite mémoire se produit lorsque vous allouez de la mémoire sur le tas sans jamais la libérer et perdez l’unique pointeur qui y mène.

La mémoire reste réservée jusqu’à la fin du programme, ce qui gaspille des ressources.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 5;
    printf("%d\n", *p);
    free(p);
    return 0;
}

Perdre le pointeur

La fuite classique consiste à écraser un pointeur avec une nouvelle allocation avant de libérer l’ancienne.

Le premier bloc devient alors inaccessible.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    free(p);
    p = malloc(sizeof(int));
    *p = 10;
    printf("%d\n", *p);
    free(p);
    return 0;
}

Les fuites dans les boucles

Allouer dans une boucle sans libérer la mémoire à chaque itération multiplie rapidement la fuite.

La solution consiste à libérer la mémoire avant que l’itération suivante n’écrase le pointeur.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    for (int i = 0; i < 3; i++) {
        int *p = malloc(sizeof(int));
        *p = i;
        printf("%d ", *p);
        free(p);
    }
    printf("\n");
    return 0;
}

Les retours anticipés provoquent des fuites

Un return anticipé après une allocation peut ignorer le nettoyage. Libérez toujours la mémoire sur chaque chemin de sortie.

#include <stdio.h>
#include <stdlib.h>

int process(int bad) {
    int *p = malloc(sizeof(int));
    if (bad) {
        free(p);
        return -1;
    }
    *p = 42;
    int r = *p;
    free(p);
    return r;
}

int main(void) {
    printf("%d\n", process(0));
    return 0;
}

Le schéma de nettoyage avec goto

Une seule étiquette de nettoyage, atteinte avec goto, garantit qu’un même endroit libère tout, ce qui évite de dupliquer les appels à free.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int rc = 1;
    int *p = malloc(sizeof(int));
    if (!p) goto done;
    *p = 7;
    printf("%d\n", *p);
    rc = 0;
done:
    free(p);
    return rc;
}

Associer chaque allocation

La règle la plus simple : pour chaque malloc, calloc ou realloc, il doit y avoir exactement un appel correspondant à free.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    char *a = malloc(8);
    char *b = calloc(4, sizeof(char));
    a[0] = 'x';
    printf("%c %d\n", a[0], b[0]);
    free(a);
    free(b);
    return 0;
}

Libérer les allocations imbriquées

Si une structure possède de la mémoire sur le tas, libérez les pointeurs internes avant de libérer le bloc extérieur.

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
} Box;

int main(void) {
    Box *b = malloc(sizeof(Box));
    b->data = malloc(3 * sizeof(int));
    b->data[0] = 1;
    printf("%d\n", b->data[0]);
    free(b->data);
    free(b);
    return 0;
}

Libérer un tableau de pointeurs

Lorsque vous allouez un tableau de pointeurs et que chaque entrée correspond à une allocation distincte, libérez d’abord chaque entrée, puis le tableau.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 3;
    int **rows = malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        rows[i] = malloc(2 * sizeof(int));
        rows[i][0] = i;
    }
    for (int i = 0; i < n; i++) free(rows[i]);
    free(rows);
    printf("freed all rows\n");
    return 0;
}

Discipline de propriété

Déterminez qui possède chaque allocation et doit la libérer. Documentez-le afin que les appelants sachent s’ils doivent libérer un pointeur renvoyé.

#include <stdio.h>
#include <stdlib.h>

char *make_greeting(void) {
    char *s = malloc(6);
    s[0]='h'; s[1]='i'; s[2]='\0';
    return s;
}

int main(void) {
    char *g = make_greeting();
    printf("%s\n", g);
    free(g);
    return 0;
}

Outils de détection des fuites

Des outils comme Valgrind et AddressSanitizer signalent les fuites en suivant chaque allocation et en indiquant celles qui n’ont jamais été libérées.

Ils sont indispensables pour vérifier de véritables programmes.

Un cycle de vie d’allocation propre

Pour résumer : allouez, vérifiez, utilisez, libérez sur chaque chemin et mettez le pointeur à NULL. Ainsi, vos programmes restent exempts de fuites.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(4 * sizeof(int));
    if (!p) return 1;
    for (int i = 0; i < 4; i++) p[i] = i + 1;
    int sum = 0;
    for (int i = 0; i < 4; i++) sum += p[i];
    printf("sum = %d\n", sum);
    free(p);
    p = NULL;
    return 0;
}

Vérification rapide

Testez votre compréhension des fuites mémoire.

Récapitulatif

Vous avez appris à éviter les fuites mémoire :

Associez chaque allocation à un seul appel à free.
Libérez la mémoire sur chaque chemin de sortie, y compris lors des retours anticipés et des erreurs.
Pour les allocations imbriquées et les tableaux de pointeurs, libérez d’abord les éléments internes.
Définissez clairement la propriété et utilisez des outils comme Valgrind pour effectuer les vérifications.

Questions Fréquemment Posées

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

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

Trouvez et évitez les fuites 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 3 sur 4.

Combien de temps prend la leçon « Fuites 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