C Academy · Leçon

calloc et realloc

Mémoire mise à zéro et redimensionnée

calloc et 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.

Au-delà de malloc

En plus de malloc, la bibliothèque standard propose calloc pour obtenir une mémoire mise à zéro et realloc pour redimensionner un bloc existant.

Les deux fonctions se trouvent dans <stdlib.h>.

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

int main(void) {
    int *p = calloc(3, sizeof(int));
    printf("%d %d %d\n", p[0], p[1], p[2]);
    free(p);
    return 0;
}

calloc met la mémoire à zéro

calloc(count, size) alloue suffisamment d’espace pour count éléments de size octets et met chaque octet à zéro.

C’est pratique lorsque vous avez besoin d’un espace vierge.

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

int main(void) {
    int *a = calloc(5, sizeof(int));
    int sum = 0;
    for (int i = 0; i < 5; i++) sum += a[i];
    printf("sum of zeroed array = %d\n", sum);
    free(a);
    return 0;
}

calloc prend deux arguments

Contrairement à malloc, calloc reçoit séparément le nombre d’éléments et la taille d’un élément.

Il protège également contre le dépassement lors de la multiplication du nombre d’éléments par la taille.

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

int main(void) {
    double *d = calloc(4, sizeof(double));
    d[2] = 1.5;
    printf("%f %f\n", d[0], d[2]);
    free(d);
    return 0;
}

malloc ou calloc

Utilisez malloc lorsque vous allez de toute façon remplacer chaque octet, et calloc lorsque vous avez besoin que la mémoire soit initialisée à zéro.

calloc coûte légèrement plus cher en raison de la mise à zéro.

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

int main(void) {
    int *m = malloc(2 * sizeof(int));
    int *c = calloc(2, sizeof(int));
    m[0] = 5; m[1] = 6;
    printf("malloc: %d %d\n", m[0], m[1]);
    printf("calloc: %d %d\n", c[0], c[1]);
    free(m); free(c);
    return 0;
}

Agrandir avec realloc

realloc(ptr, newsize) modifie la taille d’un bloc en conservant son contenu existant jusqu’à la plus petite des deux tailles, l’ancienne et la nouvelle.

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

int main(void) {
    int *a = malloc(2 * sizeof(int));
    a[0] = 1; a[1] = 2;
    a = realloc(a, 4 * sizeof(int));
    a[2] = 3; a[3] = 4;
    for (int i = 0; i < 4; i++) printf("%d ", a[i]);
    printf("\n");
    free(a);
    return 0;
}

realloc peut déplacer le bloc

realloc peut renvoyer une adresse différente s’il déplace le bloc pour trouver suffisamment d’espace.

Réaffectez toujours le résultat et ne continuez jamais à utiliser l’ancien pointeur.

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

int main(void) {
    int *a = malloc(sizeof(int));
    a[0] = 42;
    int *bigger = realloc(a, 100 * sizeof(int));
    printf("first element still %d\n", bigger[0]);
    free(bigger);
    return 0;
}

Schéma sûr avec realloc

Si realloc échoue, il renvoie NULL mais laisse le bloc d’origine intact.

Affectez d’abord le résultat à une variable temporaire afin de ne pas perdre l’ancien pointeur en cas d’échec.

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

int main(void) {
    int *a = malloc(2 * sizeof(int));
    int *tmp = realloc(a, 8 * sizeof(int));
    if (tmp == NULL) {
        free(a);
        return 1;
    }
    a = tmp;
    a[7] = 99;
    printf("%d\n", a[7]);
    free(a);
    return 0;
}

Réduire un bloc

realloc peut également réduire la taille d’un bloc. Les premiers éléments sont conservés ; le reste est libéré.

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

int main(void) {
    int *a = malloc(6 * sizeof(int));
    for (int i = 0; i < 6; i++) a[i] = i;
    a = realloc(a, 3 * sizeof(int));
    printf("%d %d %d\n", a[0], a[1], a[2]);
    free(a);
    return 0;
}

Un tampon extensible

Un schéma courant consiste à doubler la capacité lorsqu’un tableau est plein, ce qui amortit le coût de l’agrandissement.

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

int main(void) {
    int cap = 2, len = 0;
    int *a = malloc(cap * sizeof(int));
    for (int v = 0; v < 5; v++) {
        if (len == cap) {
            cap *= 2;
            a = realloc(a, cap * sizeof(int));
        }
        a[len++] = v;
    }
    printf("len=%d cap=%d last=%d\n", len, cap, a[len-1]);
    free(a);
    return 0;
}

realloc avec NULL

realloc(NULL, size) se comporte exactement comme malloc(size).

Cela permet à une routine d’agrandissement de gérer uniformément toute première allocation.

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

int main(void) {
    int *a = realloc(NULL, 3 * sizeof(int));
    a[0] = 7;
    printf("%d\n", a[0]);
    free(a);
    return 0;
}

Les combiner

Vous pouvez commencer avec calloc pour obtenir un tampon mis à zéro, puis l’agrandir avec realloc. Les nouveaux octets ajoutés après l’agrandissement ne sont pas mis à zéro.

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

int main(void) {
    int *a = calloc(2, sizeof(int));
    a = realloc(a, 4 * sizeof(int));
    a[2] = 0; a[3] = 0;
    printf("%d %d %d %d\n", a[0], a[1], a[2], a[3]);
    free(a);
    return 0;
}

Vérification rapide

Testez vos connaissances sur calloc et realloc.

Récapitulatif

Vous avez découvert deux autres outils d’allocation :

calloc(count, size) alloue de la mémoire mise à zéro et protège contre les dépassements lors de la multiplication.
realloc(ptr, newsize) redimensionne un bloc, en pouvant le déplacer.
Affectez toujours le résultat de realloc à une variable temporaire afin d’éviter les fuites en cas d’échec.
realloc(NULL, size) se comporte comme malloc.

Questions Fréquemment Posées

La leçon « calloc et realloc » est-elle gratuite ?

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

Mémoire mise à zéro et redimensionnée 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 « calloc et 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