C Academy · Leçon

malloc et free

Allouez sur le tas

malloc et free est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Le tas

Jusqu’à présent, les variables vivaient dans la pile, avec une durée de vie fixe. Le tas vous permet de demander de la mémoire à l’exécution et de la conserver aussi longtemps que nécessaire.

Vous gérez vous-même la mémoire du tas à l’aide des fonctions de <stdlib.h>.

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

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

Appeler malloc

malloc(size) réserve size octets et renvoie un pointeur vers cette zone, ou NULL en cas d’échec.

La mémoire est non initialisée : son contenu est indéterminé.

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

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

Dimensionner avec sizeof

Dimensionnez toujours les allocations avec sizeof afin que le code soit correct sur n’importe quelle plateforme.

Écrire sizeof(*p) lie automatiquement la taille au type du pointeur.

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

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

Vérifier systématiquement NULL

Si l’allocation échoue, malloc renvoie NULL. Le déréférencer fait planter le programme.

Vérifiez le résultat avant de l’utiliser.

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

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

Allouer un tableau

Pour stocker plusieurs éléments, multipliez la taille d’un élément par leur nombre.

malloc(n * sizeof(int)) crée suffisamment d’espace pour n entiers.

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

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

Les tableaux du tas utilisent l’indexation par pointeur

Un tableau du tas est accessible par son pointeur avec la syntaxe familière arr[i], qui est équivalente à *(arr + i).

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

int main(void) {
    int *arr = malloc(3 * sizeof(int));
    arr[0] = 10;
    *(arr + 1) = 20;
    arr[2] = 30;
    printf("%d %d %d\n", arr[0], arr[1], arr[2]);
    free(arr);
    return 0;
}

Libérer la mémoire

free(p) rend le bloc à l’allocateur. Après cela, vous ne devez plus utiliser p pour accéder à cette mémoire.

Chaque appel réussi à malloc doit être associé à un appel correspondant à free.

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

int main(void) {
    char *buf = malloc(16);
    if (buf) {
        buf[0] = 'A';
        printf("%c\n", buf[0]);
        free(buf);
    }
    return 0;
}

free(NULL) est sans danger

Appeler free sur un pointeur NULL ne fait rien et est parfaitement légal.

Cela simplifie le code de nettoyage qui peut s’exécuter avant la réussite de l’allocation.

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

int main(void) {
    int *p = NULL;
    free(p);
    printf("free(NULL) was safe\n");
    return 0;
}

Renvoyer de la mémoire du tas

Contrairement aux variables de la pile, la mémoire du tas subsiste après le retour de la fonction. Une fonction peut ainsi allouer et renvoyer un tampon.

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

int *make_range(int n) {
    int *a = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) a[i] = i;
    return a;
}

int main(void) {
    int *r = make_range(4);
    printf("%d %d\n", r[0], r[3]);
    free(r);
    return 0;
}

Ne transtypez pas malloc en C

En C, malloc renvoie un void * qui se convertit automatiquement vers n’importe quel type de pointeur.

Le transtyper est inutile et peut dissimuler l’absence de l’inclusion de <stdlib.h>.

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

int main(void) {
    long *p = malloc(sizeof(long));
    *p = 1234567L;
    printf("%ld\n", *p);
    free(p);
    return 0;
}

Ne libérez pas deux fois

Appeler free deux fois sur le même pointeur constitue un comportement indéfini et peut endommager le tas.

Après la libération, affectez NULL au pointeur afin de rendre toute réutilisation accidentelle inoffensive.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 1;
    free(p);
    p = NULL;
    free(p);
    printf("no double free\n");
    return 0;
}

Vérification rapide

Testez vos connaissances sur malloc et free.

Récapitulatif

Vous avez découvert les bases de l’allocation sur le tas :

malloc(size) réserve des octets non initialisés et renvoie NULL en cas d’échec.
Vérifiez toujours le résultat et dimensionnez l’allocation avec sizeof.
free(p) rend la mémoire ; chaque appel à malloc nécessite un appel à free.
free(NULL) est sans danger ; une double libération est indéfinie.

Questions Fréquemment Posées

La leçon « malloc et free » est-elle gratuite ?

Oui — le texte complet de « malloc et free » 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 « malloc et free » ?

Allouez sur le tas 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 1 sur 4.

Combien de temps prend la leçon « malloc et free » ?

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