0Pricing
C Academy · Leçon

Pointeurs pendants

Dangers de l’utilisation après libération

Pointeurs pendants 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.

Qu'est-ce qu'un pointeur suspendu

Un pointeur suspendu pointe vers une zone mémoire qui a déjà été libérée ou qui n'est plus valide.

Son utilisation entraîne un comportement indéfini : plantages, corruption ou bogues silencieux.

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

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

Utilisation après libération

La cause la plus courante est de lire ou d'écrire via un pointeur après free.

Le bloc a peut-être été réutilisé pour autre chose.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 42;
    free(p);
    /* Reading *p here would be use-after-free. */
    p = NULL;
    printf("avoided use-after-free\n");
    return 0;
}

NULL après libération

Définir un pointeur sur NULL juste après la libération transforme une utilisation accidentelle en plantage explicite, ou en appel sans danger à free(NULL).

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

int main(void) {
    char *buf = malloc(10);
    buf[0] = 'A';
    free(buf);
    buf = NULL;
    if (buf == NULL) printf("buf is safely null\n");
    return 0;
}

Renvoyer l'adresse d'une variable locale

Renvoyer l'adresse d'une variable locale (sur la pile) crée un pointeur suspendu : la variable disparaît lorsque la fonction se termine.

Utilisez le tas ou transmettez plutôt un tampon.

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

int *make_value(int v) {
    int *p = malloc(sizeof(int));
    *p = v;
    return p;
}

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

Plusieurs pointeurs vers un même bloc

Si deux pointeurs font référence au même bloc, libérer celui-ci via l'un rend l'autre suspendu.

Suivez la propriété afin que seul le propriétaire libère le bloc.

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

int main(void) {
    int *a = malloc(sizeof(int));
    *a = 7;
    int *b = a;
    printf("%d\n", *b);
    free(a);
    a = NULL;
    b = NULL;
    printf("both nulled\n");
    return 0;
}

Pointeur suspendu après realloc

Lorsque realloc déplace un bloc, tout ancien pointeur vers l'emplacement précédent devient suspendu.

Utilisez uniquement le pointeur renvoyé par realloc.

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

int main(void) {
    int *a = malloc(sizeof(int));
    a[0] = 1;
    int *b = realloc(a, 50 * sizeof(int));
    /* a may now be dangling; use only b. */
    b[0] = 2;
    printf("%d\n", b[0]);
    free(b);
    return 0;
}

Libération dans une fonction auxiliaire

Si une fonction auxiliaire libère un bloc, le pointeur de l'appelant devient suspendu. Mettez-le à NULL après l'appel ou concevez la fonction auxiliaire pour qu'elle reçoive un pointeur vers un pointeur.

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

void destroy(int **p) {
    free(*p);
    *p = NULL;
}

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 5;
    destroy(&p);
    printf("p is %s\n", p == NULL ? "null" : "set");
    return 0;
}

Pourquoi est-ce dangereux

L'utilisation après libération est dangereuse, car la mémoire peut désormais contenir d'autres données. Les écritures peuvent corrompre un état sans rapport, et des attaquants peuvent exploiter cette situation.

Pointeurs suspendus liés à la portée

Un pointeur vers une variable dont la portée est limitée à un bloc devient invalide lorsque le bloc se termine. Ne conservez pas les pointeurs plus longtemps que la durée de vie de ce vers quoi ils pointent.

#include <stdio.h>

int main(void) {
    int *p;
    {
        int x = 10;
        p = &x;
        printf("in scope: %d\n", *p);
    }
    /* p now dangles; do not dereference it here. */
    printf("block ended\n");
    return 0;
}

Détecter les pointeurs suspendus

Des outils comme AddressSanitizer et Valgrind détectent les utilisations après libération à l'exécution et indiquent la ligne exacte.

Compilez avec des désinfecteurs pendant le développement.

Récapitulatif du cycle de vie sûr en code

Allouez, utilisez, libérez, puis mettez à NULL. En appliquant systématiquement cette règle, vous évitez que les pointeurs deviennent suspendus.

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

int main(void) {
    int *p = malloc(sizeof(int));
    if (!p) return 1;
    *p = 123;
    printf("%d\n", *p);
    free(p);
    p = NULL;
    return 0;
}

Vérification rapide

Vérifiez votre compréhension des pointeurs suspendus.

Récapitulatif

Vous avez découvert les pointeurs suspendus :

  • Ils pointent vers une mémoire libérée ou hors de portée ; les utiliser entraîne un comportement indéfini.
  • Évitez de renvoyer les adresses de variables locales ; n'utilisez jamais un pointeur après free ou après que realloc a déplacé un bloc.
  • Définissez les pointeurs sur NULL après une libération et suivez la propriété.
  • Utilisez des désinfecteurs et Valgrind pour détecter les utilisations après libération.

Questions Fréquemment Posées

La leçon « Pointeurs pendants » est-elle gratuite ?

Oui — le texte complet de « Pointeurs pendants » 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 « Pointeurs pendants » ?

Dangers de l’utilisation après libération 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 « Pointeurs pendants » ?

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

  1. malloc et free
  2. calloc et realloc
  3. Fuites de mémoire
  4. Pointeurs pendants
← Retour à C Academy