malloc vs calloc : Différences clés expliquées avec exemples pratiques

Qu'est-ce que l'allocation mémoire dynamique ?

L'allocation mémoire dynamique permet à un programme de demander et libérer de la mémoire à l'exécution. En C, la bibliothèque standard fournit quatre fonctions principales à cet effet – malloc(), calloc(), realloc() et free() – toutes déclarées dans stdlib.h.

malloc() : Allouer un bloc unique de mémoire

malloc() (abréviation de « memory allocation ») réserve un bloc contigu d'octets et retourne un pointeur vers le premier octet. Le contenu du bloc nouvellement alloué est indéterminé (valeurs résiduelles aléatoires).

Utilisation typique :

int *p = (int *)malloc(n * sizeof(int));

Si la requête échoue, malloc() retourne NULL.

calloc() : Allouer plusieurs blocs initialisés à zéro

calloc() (abréviation de « contiguous allocation ») prend deux arguments : le nombre d'éléments et la taille de chaque élément. Il alloue la mémoire pour tous les éléments et met automatiquement chaque octet à zéro, ce qui est idéal pour les tableaux ou structures nécessitant un état initial propre.

Utilisation typique :

int *p = (int *)calloc(n, sizeof(int));

Comme malloc(), il retourne NULL en cas d'échec.

Quand utiliser chaque fonction

• malloc() – Utilisez quand vous avez besoin d'un bloc unique et que vous initialiserez la mémoire vous-même. Légèrement plus rapide car il saute l'étape de mise à zéro.
• calloc() – Utilisez quand vous avez besoin d'un tableau ou structure qui doit commencer avec des zéros. L'initialisation automatique protège contre l'utilisation accidentelle de valeurs indéterminées.

Aperçu de la syntaxe

malloc()

void *malloc(size_t size);

calloc()

void *calloc(size_t num, size_t size);

Exemples de code pratiques

Exemple 1 : Utilisation de malloc() pour stocker 15 entiers

#include <stdlib.h>
#include <stdio.h>
int main(void) {
    int *ptr = malloc(15 * sizeof(*ptr));
    if (!ptr) {
        perror("malloc failed");
        return EXIT_FAILURE;
    }
    ptr[5] = 480; // 6ème élément (index 0-based)
    printf("Value of the 6th integer is %d\n", ptr[5]);
    free(ptr);
    return EXIT_SUCCESS;
}

Sortie : Value of the 6th integer is 480

Exemple 2 : Utilisation de calloc() pour calculer une somme

#include <stdlib.h>
#include <stdio.h>
int main(void) {
    int *ptr = calloc(10, sizeof(int));
    if (!ptr) {
        perror("calloc failed");
        return EXIT_FAILURE;
    }
    int sum = 0;
    for (int i = 0; i < 10; ++i) {
        ptr[i] = i; // initialisation redondante mais montrée pour la clarté
        sum += ptr[i];
    }
    printf("Sum = %d\n", sum);
    free(ptr);
    return EXIT_SUCCESS;
}

Sortie : Sum = 45

Comparaison côte à côte

Caractéristique	malloc()	calloc()
Nombre de paramètres	1 (taille)	2 (nombre, taille)
État mémoire après allocation	Non initialisé (valeurs indéterminées)	Initialisé à zéro
Cas d'usage typique	Bloc unique, initialisation manuelle	Tableaux ou structures nécessitant un début propre
Performance	Plus rapide (pas de mise à zéro)	Plus lent (surcoût de mise à zéro)
Sécurité	Risque accru d'utiliser des valeurs indéterminées	Risque réduit grâce à la mise à zéro automatique
Valeur de retour en cas d'échec	NULL	NULL
En-tête standard	stdlib.h	stdlib.h

Points clés à retenir

• Utilisez malloc() quand vous avez besoin d'un bloc unique et l'initialiserez vous-même pour un léger gain de performance.
• Utilisez calloc() quand vous avez besoin de mémoire initialisée à zéro, surtout pour les tableaux ou structures, pour éviter les bugs subtils.
• Les deux fonctions retournent NULL en cas d'échec ; vérifiez toujours avant de déréférencer.
• N'oubliez pas de libérer la mémoire allouée avec free() pour éviter les fuites mémoire.