C Academy · Leçon

Comment fonctionne malloc

Le tas et les listes libres.

Comment fonctionne malloc 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.

Ce que fait réellement malloc

Lorsque vous appelez malloc(n), la bibliothèque C vous remet un pointeur vers au moins n octets utilisables. Mais le tas n’est qu’une région de la mémoire du processus que l’allocateur gère pour vous.

Le rôle de l’allocateur est de tenir les registres : suivre les octets utilisés, ceux qui sont libres et la manière de réutiliser efficacement la mémoire libérée.

Le tas vient de l’OS

L’allocateur ne crée pas la mémoire à partir de rien. Il demande de grandes zones au système d’exploitation au moyen d’appels système comme brk/sbrk ou mmap.

Il découpe ensuite ces zones en blocs plus petits pour vos appels à malloc. Demander de la mémoire à l’OS coûte cher ; les allocateurs en demandent donc de grandes quantités et la recyclent.

/* Conceptual: grow the heap by 4096 bytes */
void *base = sbrk(4096);
if (base == (void *)-1) {
    /* out of memory */
}

sbrk et la limite du programme

sbrk(n) déplace la « limite du programme » de n octets vers le haut et renvoie l’ancienne limite. La nouvelle région ainsi exposée devient disponible dans le tas.

Cette méthode est linéaire et simple, mais elle ne permet pas facilement de rendre de la mémoire située au milieu. Les allocateurs modernes préfèrent mmap pour les grandes demandes.

void *prev_break = sbrk(0);   /* current break */
sbrk(1024);                   /* grow by 1 KB */
/* prev_break now points to fresh memory */

Métadonnées d’un bloc

Pour chaque allocation, l’allocateur stocke un petit en-tête à côté des données : sa taille et l’indication précisant s’il est libre. Cet en-tête permet à free de fonctionner avec le seul pointeur de données que vous lui rendez.

Le pointeur reçu de malloc pointe après l’en-tête, de sorte que les métadonnées restent invisibles pour vous.

typedef struct block {
    size_t size;
    int free;
    struct block *next;
} block_t;

Pointeur juste après l’en-tête

Une astuce courante consiste à utiliser l’arithmétique des pointeurs : le pointeur utilisateur vaut header + 1. À partir d’un pointeur utilisateur, l’en-tête se trouve un block_t avant celui-ci.

C’est ainsi que free(p) retrouve la taille du bloc que vous avez alloué, sans que vous ayez à la lui transmettre.

block_t *hdr = (block_t *)user_ptr - 1;
printf("block size = %zu\n", hdr->size);

Démonstration d’une petite structure d’en-tête

Plaçons un en-tête dans un tampon statique et relisons-le. Cela montre comment un allocateur réel divise une région en en-tête et charge utile.

Aucun appel à l’OS n’est effectué, le programme s’exécute donc partout.

#include <stdio.h>
#include <stddef.h>

typedef struct { size_t size; int free; } block_t;
static char buffer[256];

int main(void) {
    block_t *h = (block_t *)buffer;
    h->size = 64;
    h->free = 0;
    void *payload = (char *)buffer + sizeof(block_t);
    printf("header bytes = %zu\n", sizeof(block_t));
    printf("payload offset = %ld\n", (long)((char *)payload - buffer));
    printf("size field = %zu\n", h->size);
    return 0;
}

Le principe de la liste des blocs libres

De nombreux allocateurs relient les blocs libres dans une liste chaînée. Lorsque vous appelez malloc, l’allocateur parcourt cette liste à la recherche d’un bloc suffisamment grand.

Lorsque vous appelez free, le bloc est marqué comme libre et réinséré dans la liste pour être réutilisé ultérieurement, ce qui évite une nouvelle demande à l’OS.

block_t *find_free(block_t *head, size_t size) {
    block_t *b = head;
    while (b && !(b->free && b->size >= size))
        b = b->next;
    return b;
}

Ce que free doit faire

free(p) trouve l’en-tête de p, le marque comme libre et, idéalement, le fusionne avec les blocs libres adjacents afin de lutter contre la fragmentation.

Appeler deux fois free avec le même pointeur ou libérer un pointeur qui ne provient pas du tas provoque un comportement indéfini, car les métadonnées sont alors corrompues.

void my_free(void *p) {
    if (!p) return;
    block_t *hdr = (block_t *)p - 1;
    hdr->free = 1;
    /* real allocators coalesce neighbors here */
}

Fragmentation

Au fil du temps, la libération et l’allocation de tailles différentes laissent des espaces vides. La fragmentation externe signifie que de la mémoire libre existe, mais qu’elle est dispersée en morceaux trop petits pour satisfaire une demande.

La fragmentation interne correspond à l’espace inutilisé à l’intérieur d’un bloc plus grand que nécessaire, souvent à cause de l’alignement ou de l’arrondi.

Exigences d’alignement

malloc doit renvoyer une mémoire alignée pour n’importe quel type. Sur la plupart des systèmes 64 bits, cela signifie un alignement de 16 octets, conforme à max_align_t.

Des pointeurs mal alignés peuvent provoquer un plantage sur certains processeurs ou ralentir les accès sur d’autres ; les allocateurs arrondissent donc toujours les charges utiles à la limite d’alignement supérieure.

#include <stdalign.h>
/* alignof(max_align_t) is the strictest required alignment */
size_t a = alignof(max_align_t);

Assembler les éléments

Un allocateur minimal a donc besoin d’une source de mémoire (tampon statique, sbrk ou mmap), d’en-têtes pour chaque bloc, d’une stratégie de recherche d’espace libre et d’une gestion de l’alignement.

Dans les prochaines leçons, nous construirons ces éléments : d’abord un allocateur par déplacement, puis des listes de blocs libres, enfin l’alignement et le découpage des blocs.

/* The four pillars of a custom allocator */
/* 1. memory source   2. block headers */
/* 3. free-block search   4. alignment */

Vérification rapide

Testez votre compréhension du fonctionnement interne des allocateurs.

Récapitulatif

La fonction malloc gère un tas obtenu auprès de l’OS via sbrk ou mmap, en le découpant en blocs dotés d’en-têtes cachés qui indiquent leur taille et leur état libre.

Les listes de blocs libres permettent la réutilisation, l’alignement convient à tous les types et la fragmentation constitue le principal défi. Ces idées orientent l’allocateur que nous allons construire.

Questions Fréquemment Posées

La leçon « Comment fonctionne malloc » est-elle gratuite ?

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

Le tas et les listes libres. 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 « Comment fonctionne malloc » ?

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