C Academy · Leçon

Agrandir avec realloc

Redimensionnez un tableau dynamique.

Agrandir avec realloc est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Quand un seul malloc ne suffit pas

Vous pouvez parfois allouer un tableau, le remplir, puis découvrir que vous avez besoin de plus de place. Vous ne pouvez pas simplement écrire au-delà de sa fin.

realloc vous permet de redimensionner un bloc existant du tas tout en conservant les données qui s’y trouvaient déjà.

La signature de realloc

realloc(ptr, new_bytes) reçoit l’ancien pointeur et la nouvelle taille totale en octets.

Elle renvoie un pointeur vers un bloc de la nouvelle taille. La première partie des données est conservée jusqu’à la plus petite des anciennes et nouvelles tailles.

int *bigger = realloc(a, new_n * sizeof(*a));

Le bloc peut être déplacé

realloc peut agrandir le bloc sur place, ou bien allouer un nouveau bloc, y copier vos données et libérer l’ancien.

Dans les deux cas, l’ancien pointeur peut devenir invalide. Vous devez désormais utiliser le pointeur renvoyé.

a = realloc(a, new_n * sizeof(*a));
/* the old value of a may no longer be valid */

Le piège de l’auto-affectation

Écrire a = realloc(a, ...) semble pratique, mais c’est dangereux : si realloc renvoie NULL, vous avez écrasé a et perdu le pointeur d’origine, ce qui provoque une fuite de l’ancien bloc.

Utilisez plutôt une variable temporaire.

int *tmp = realloc(a, new_n * sizeof(*a));
if (tmp == NULL) { /* a is still valid */ return 1; }
a = tmp;

Agrandir un tableau en toute sécurité

Ce programme alloue 3 variables de type int, puis agrandit le tableau à 6 éléments avec realloc en conservant les trois premières valeurs.

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

int main(void) {
    int *a = malloc(3 * sizeof(*a));
    if (!a) return 1;
    for (int i = 0; i < 3; i++) a[i] = i + 1;

    int *tmp = realloc(a, 6 * sizeof(*a));
    if (!tmp) { free(a); return 1; }
    a = tmp;

    for (int i = 3; i < 6; i++) a[i] = i + 1;
    for (int i = 0; i < 6; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

Les nouveaux octets ne sont pas initialisés

Lorsque vous agrandissez un bloc, l’espace supplémentaire à la fin contient des valeurs indéterminées, comme la mémoire nouvellement obtenue avec malloc.

realloc conserve vos anciennes données, mais n’initialise pas la nouvelle zone à zéro. Initialisez-la avant de la lire.

a = realloc(a, 6 * sizeof(*a));
for (int i = 3; i < 6; i++) a[i] = 0;  /* clear new slots */

La stratégie du doublement

Appeler realloc pour chaque élément est lent. Une astuce classique consiste à doubler la capacité chaque fois que vous manquez de place.

Le nombre d’appels à realloc reste ainsi faible lorsque le tableau grandit, ce qui offre de bonnes performances moyennes.

if (count == cap) {
    cap = cap ? cap * 2 : 4;
    int *tmp = realloc(a, cap * sizeof(*a));
    if (!tmp) { free(a); return 1; }
    a = tmp;
}

Construire un tableau par ajouts successifs

Ce programme commence avec un tableau vide et ajoute des nombres à la fin, en doublant la capacité lorsque c’est nécessaire.

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

int main(void) {
    int *a = NULL;
    size_t count = 0, cap = 0;
    for (int v = 1; v <= 5; v++) {
        if (count == cap) {
            cap = cap ? cap * 2 : 2;
            int *tmp = realloc(a, cap * sizeof(*a));
            if (!tmp) { free(a); return 1; }
            a = tmp;
        }
        a[count++] = v;
    }
    for (size_t i = 0; i < count; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

realloc(NULL, n) agit comme malloc

Si vous transmettez NULL comme pointeur, realloc se comporte exactement comme malloc.

C’est pourquoi commencer par a = NULL fonctionne dans la boucle de doublement : le tout premier appel à realloc alloue le bloc initial.

int *a = NULL;
a = realloc(a, 4 * sizeof(*a));  /* same as malloc(4 * sizeof(*a)) */

Réduire un bloc

realloc peut également rendre un bloc plus petit. Les données jusqu’à la nouvelle taille sont conservées ; le reste est supprimé.

La réduction peut rendre de la mémoire au système, même si les implémentations sont libres de conserver le bloc plus grand.

int *tmp = realloc(a, 2 * sizeof(*a));  /* down from more */
if (tmp) a = tmp;

Éviter les dépassements en calcul arithmétique

Lorsque la capacité devient importante, cap * sizeof(*a) peut dépasser la capacité d'un size_t et revenir à une valeur minuscule.

Pour les tableaux très volumineux, protégez la multiplication ou utilisez reallocarray sur les systèmes qui le proposent.

if (cap > SIZE_MAX / sizeof(*a)) { /* overflow */ return 1; }
int *tmp = realloc(a, cap * sizeof(*a));

Vérification rapide

Vérifiez votre compréhension de realloc.

Récapitulatif

realloc redimensionne un bloc du tas et peut le déplacer ; utilisez donc toujours le pointeur renvoyé.

Affectez-le à une variable temporaire afin qu'un échec ne provoque pas la fuite du bloc d'origine. Doublez la capacité pour gagner en rapidité, initialisez les nouveaux emplacements et retenez que realloc(NULL, n) équivaut à malloc. Vous allez maintenant encapsuler cette logique dans un type de vecteur réutilisable.

Questions Fréquemment Posées

La leçon « Agrandir avec realloc » est-elle gratuite ?

Oui — le texte complet de « Agrandir avec realloc » 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 « Agrandir avec realloc » ?

Redimensionnez un tableau dynamique. 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 2 sur 4.

Combien de temps prend la leçon « Agrandir avec realloc » ?

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