Menu
CoddyTech

Allouer avec calloc()

Fait partie de la section Logique & Flux du Journey C de Coddy. Leçon 36 sur 63.

Bien que malloc() soit la fonction la plus couramment utilisée pour l’allocation dynamique de mémoire, C propose une autre solution utile : calloc(). La fonction calloc(), abréviation de « allocation contiguë », offre un moyen pratique d’allouer de la mémoire pour des tableaux, avec un avantage supplémentaire important.

Contrairement à malloc(), qui prend un seul argument (le nombre total d’octets), calloc() prend deux arguments : le nombre d’éléments que tu veux allouer et la taille de chaque élément. Cela la rend particulièrement intuitive pour travailler avec des tableaux. Par exemple :

#include <stdlib.h>

// Allouez de l’espace pour 5 entiers avec calloc()
int *arr = (int*)calloc(5, sizeof(int));

// Cela équivaut à : malloc(5 * sizeof(int))

Le principal avantage de calloc() est qu’il initialise automatiquement toute la mémoire allouée à zéro. Lorsque tu utilises malloc(), la mémoire allouée contient les valeurs aléatoires qui y étaient stockées auparavant, mais calloc() garantit que chaque octet est mis à zéro. Cela signifie que tous les entiers seront égaux à 0, tous les nombres flottants à 0.0 et tous les pointeurs à NULL.

Comme malloc(), calloc() renvoie un pointeur vers la mémoire allouée ou NULL si l’allocation échoue. Tu dois donc toujours vérifier si l’allocation a échoué et penser à free() la mémoire lorsque tu as fini de l’utiliser.

challenge icon

Défi

Facile

Écris un programme en C qui illustre l’utilisation de calloc() pour l’allocation dynamique de mémoire avec initialisation automatique à zéro. Ton programme doit :

  1. Lire auprès de l’utilisateur un entier size représentant le nombre d’entiers à allouer
  2. Utiliser calloc() pour allouer dynamiquement de la mémoire pour un tableau de size entiers
  3. Vérifier si l’allocation de mémoire a réussi : en cas d’échec, afficher Memory allocation failed! et terminer le programme
  4. Si l’allocation réussit, afficher Memory allocated and initialized to zero!
  5. Afficher toutes les valeurs initiales du tableau pour montrer qu’elles sont égales à zéro, au format : Initial values: [value1] [value2] [value3] ...
  6. Lire size valeurs entières auprès de l’utilisateur et les stocker dans le tableau alloué
  7. Afficher toutes les valeurs mises à jour au format : Updated values: [value1] [value2] [value3] ...
  8. Calculer et afficher la somme de toutes les valeurs au format : Sum: [value]
  9. Utiliser free() pour désallouer la mémoire
  10. Afficher Memory freed! pour confirmer le nettoyage

N’oublie pas d’inclure l’en-tête <stdlib.h> pour utiliser calloc() et free(). Ce défi illustre le principal avantage de calloc() par rapport à malloc() : l’initialisation automatique à zéro de toute la mémoire allouée.

Par exemple, si l’entrée est :

3
10 20 30

Ta sortie devrait être :

Memory allocated and initialized to zero!
Initial values: 0 0 0
Updated values: 10 20 30
Sum: 60
Memory freed!

Ce défi met en évidence la façon dont calloc() fournit un état initial propre et prévisible pour tes tableaux alloués dynamiquement, en éliminant les valeurs indéterminées que malloc() pourrait laisser en mémoire.

Essayez vous-même

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

int main() {
    int size;
    
    // Lisez la taille du tableau
    scanf("%d", &size);
    
    // TODO: Écrivez votre code ci-dessous
    // Utilisez calloc() pour allouer de la mémoire au tableau
    // Vérifiez si l’allocation a réussi
    // Affichez les valeurs initiales (elles doivent être nulles)
    // Lisez et stockez les valeurs saisies
    // Affichez les valeurs mises à jour
    // Calculez et affichez la somme
    // Libérez la mémoire allouée
    
    return 0;
}
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

Entraînez-vous par vous-même : Compilateur C en ligne