Fonction calloc() dans la bibliothèque C avec EXEMPLE de programme

Qu’est-ce que calloc en C ?

La fonction `calloc()` en C permet d'allouer plusieurs blocs de mémoire de même taille. Il s'agit d'une fonction d'allocation dynamique de mémoire qui alloue de l'espace mémoire à des structures de données complexes telles que des tableaux et des structures, et qui renvoie un pointeur vers la mémoire. `calloc` signifie « allocation contiguë ».

Fonction Malloc est utilisée pour allouer un seul bloc d'espace mémoire tandis que la fonction calloc en C est utilisée pour allouer plusieurs blocs d'espace mémoire. Chaque bloc alloué par le calloc en programmation C est de la même taille.

Pourquoi utiliser calloc() en C ?

Les variables ordinaires et les tableaux de taille fixe verrouillent leurs dimensions lors de la compilation, ce qui gaspille de l'espace lorsque peu d'éléments sont nécessaires et provoque une erreur lorsque davantage d'éléments sont requis. La fonction `calloc()` supprime cette limitation en réservant de la mémoire à l'exécution et, contrairement à `malloc()`, elle efface chaque octet avant de libérer le bloc. De ce fait, `calloc()` est le choix idéal lorsqu'un programme a besoin d'une zone mémoire propre et prévisible pour un tableau ou une structure dont la taille n'est connue qu'à l'exécution du code.

L'allocation dynamique avec calloc() convient à plusieurs situations courantes :

• Les tableaux numériques qui doivent commencer à zéro, tels que les compteurs, les histogrammes ou les accumulateurs cumulatifs.
• Des structures de données où des valeurs résiduelles indésirables pourraient entraîner des problèmes subtils et difficiles à détecter.tracet les insectes.
• Bufferdont la longueur dépend des données saisies par l'utilisateur ou d'un fichier lu pendant l'exécution du programme.
• Blocs trop volumineux pour la pile limitée, car calloc() puise dans le tas, beaucoup plus grand.

Étant donné que le bloc réservé est contigu et déjà initialisé à zéro, il peut être traité immédiatement comme un tableau prêt à l'emploi sans boucle d'initialisation séparée.

calloc() Syntaxe :

ptr = (cast_type *) calloc (n, size);

• L'exemple d'instruction ci-dessus de calloc en C est utilisé pour allouer n blocs de mémoire de même taille.
• Une fois l’espace mémoire alloué, tous les octets sont initialisés à zéro.
• Le aiguille qui se trouve actuellement au premier octet de l'espace mémoire alloué est renvoyé.

Chaque fois qu'il y a une erreur lors de l'allocation de l'espace mémoire, telle qu'un manque de mémoire, un pointeur nul est renvoyé, comme indiqué dans l'exemple de calloc ci-dessous.

Comment utiliser calloc

Le programme calloc ci-dessous en C calcule la somme d'une séquence arithmétique.

#include <stdio.h>
    int main() {
        int i, * ptr, sum = 0;
        ptr = calloc(10, sizeof(int));
        if (ptr == NULL) {
            printf("Error! memory not allocated.");
            exit(0);
        }
        printf("Building and calculating the sequence sum of the first 10 terms \ n ");
        for (i = 0; i < 10; ++i) { * (ptr + i) = i;
            sum += * (ptr + i);
        }
        printf("Sum = %d", sum);
        free(ptr);
        return 0;
    }

Résultat du calloc dans l'exemple C :

 
Building and calculating the sequence sum of the first 10 terms
Sum = 45

Différence entre calloc() et malloc()

Les fonctions calloc() et malloc() réservent toutes deux de la mémoire sur le tas et renvoient toutes deux un pointeur void, ou NULL en cas d'échec ; cependant, elles diffèrent sur trois points pratiques qui déterminent laquelle utiliser.

• Initialisation : calloc() initialise chaque octet du nouveau bloc à zéro, tandis que malloc() laisse le contenu non initialisé ; un bloc malloc() contient donc des données imprévisibles jusqu’à ce que le programme y écrive.
• Arguments : calloc() prend deux arguments, le nombre d’éléments et la taille de chacun, écrit calloc(n, taille) ; malloc() prend un seul argument, le nombre total d’octets, écrit malloc(n * taille).
• Vitesse : malloc() est légèrement plus rapide car il saute l’étape d’initialisation à zéro, c’est pourquoi le code qui écrase immédiatement la mémoire le préfère souvent.

Ces deux fonctions sont déclarées dans stdlib.h et libèrent toutes deux la mémoire grâce à la même fonction free(). Privilégiez calloc() lorsqu'il est important d'avoir un bloc initialisé à zéro, et malloc() lorsque la vitesse brute est préférable et que le programme gère lui-même l'initialisation.

Comment libérer la mémoire allouée par calloc()

La mémoire réservée par `calloc()` est stockée dans le tas et n'est jamais libérée automatiquement. Lorsqu'un programme alloue de la mémoire sans la libérer, il consomme progressivement toute la mémoire disponible, un défaut appelé fuite de mémoire. La fonction `free()` libère un bloc de mémoire afin que cet espace puisse être réutilisé par d'autres allocations.

La fonction free() prend un seul argument, le pointeur renvoyé par calloc(), et libère l'intégralité du bloc en une seule fois :

int *ptr;
ptr = calloc(10, sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

Suivez ces règles pour gérer la mémoire de calloc() en toute sécurité :

• Appelez free() une seule fois pour chaque appel réussi à calloc() ; libérer le même bloc deux fois provoque un comportement indéfini.
• Après avoir libéré le pointeur, définissez sa valeur sur NULL afin qu'il ne puisse pas être réutilisé comme pointeur orphelin.
• N'utilisez jamais free() sur un pointeur que calloc() n'a pas renvoyé, y compris un pointeur décalé par des opérations arithmétiques sur les pointeurs.
• Associez chaque allocation à une libération avant que le pointeur ne sorte de la portée.

Comme calloc() et malloc() puisent toutes deux dans le même tas, la discipline de libération est identique pour les deux fonctions : un appel à free() pour chaque allocation réussie, et aucun accès au bloc par la suite.ping L'allocation et la libération équilibrées constituent la principale pratique de gestion manuelle de la mémoire en C, et elles permettent d'éviter à la fois les fuites et les plantages causés par la réutilisation de mémoire déjà libérée.

FAQ