Calloc en c

«L'utilisation et l'attribution de la mémoire ou de l'espace dans un système sont censées être la chose la plus importante dans tout script de programmation lorsque vous avez beaucoup de données sous forme de variables et de tableaux. Le langage C est très dynamique lorsqu'il s'agit d'allocation de la mémoire car il contient de nombreuses fonctions spécifiques à la mémoire. L'une de ces fonctions est calloc (). L'allocation contigu est un autre nom pour le «calloc». Cette méthode de langue C alloue la mémoire dynamique à un certain type. Cette technique est utilisée pour allouer dynamiquement le nombre souhaité de blocs de mémoire d'un type particulier."

Cette approche est assez similaire à la méthode malloc du langage C, mais il y a deux différences ci-dessous:

1. Chaque bloc de cette fonction reçoit une initialisation zéro, et un type spécifique est alloué.
2. Par rapport à Malloc, il contient deux arguments ou paramètres.

Syntaxe

(Cast-Type *) calloc (n, taille);

Nous pouvons lancer la mémoire retournée à n'importe quel type de mémoire approprié car cette fonction renvoie un pointeur vide à l'adresse nécessaire en mémoire. Par exemple:

ptr = (int *) calloc (20, sizeof (int));

Le code ci-dessus est utilisé pour allouer 20 blocs de mémoire contigus de taille entier, chacun contenant 20 éléments.

Exemple 1

Commençons par écrire un code simple. Dans cet exemple, nous utilisons Visual Studio pour créer un projet C vide et ajoutant un fichier nommé comme ForKexample.C dans le répertoire / dossier des fichiers source. Examinez le code dans la section ci-dessous. Les deux premières lignes de l'échantillon ci-dessous sont utilisées pour inclure les fichiers d'en-tête nécessaires. Ensuite, la fonction principale commence. Prenez note de l'utilisation de (float *) pour changer le pointeur vide en un pointeur flottant. Cette commande à l'intérieur de la fonction principale alloue l'espace mémoire contigu en utilisant la fonction calloc pour 25 éléments, chacun de la taille du flotteur.

Étant donné que cette mémoire est dynamique, elle sera allouée lors de l'exécution du fichier; Cependant, il sera publié après la fin du cycle d'exécution du programme. Il montre uniquement comment une allocation de mémoire peut être effectuée à l'aide de la fonction Calloc; Aucune sortie spécifique ne sera présentée à l'utilisateur à l'écran car aucune fonction printf n'est utilisée. L'instruction conditionnelle doit être utilisée pour déterminer si la mémoire a été allouée ou non.

#inclure
#inclure
int main()
float * a = (float *) calloc (25, sizeof (float));
retour 0;

Exemple 2

Les deux premières lignes de l'exemple de code ci-dessous incluent les fichiers d'en-tête nécessaires. La méthode principale commence alors. Dans la première ligne de la fonction principale, nous avons jeté le type de données ponctuel à un entier et utilisons la fonction calloc pour allouer 25 blocs de mémoire avec une taille entière. Nous avons déclaré une variable de type entier dans la ligne suivante, que nous utiliserons plus tard pour afficher la sortie à l'écran. Dans la phrase suivante, nous utilisons la condition IF pour déterminer si le point de calloc renvoie une valeur nulle ou non. Ce n'est que dans ces circonstances, comme lorsqu'une allocation échoue ou que l'espace mémoire n'est pas alloué, la valeur nulle revient-elle.

Dans cette situation, nous utilisons la fonction printf pour afficher le message «Mémoire non autorisée» ou «calloc n'a pas réussi à allouer la mémoire."Nous montrons le message de réussite à l'écran d'une autre manière. L'entrée de l'utilisateur est collectée sur la ligne suivante et stockée dans la variable déclarée précédente.

#inclure
#inclure
int main()
int * pointer = (int *) calloc (25, sizeof (int));
int a;
if (pointer == null)
printf ("Mémoire non allouée.\ n ");
autre
printf ("La mémoire a été allouée avec succès à l'aide de la fonction calloc.\ n ");
scanf ("% d", & a);
retour 0;

Voici la sortie de l'écran montrant que la méthode calloc alloue avec succès la mémoire.

Essayons d'échouer cette procédure en apportant une petite modification du code indiqué ci-dessus. Pour ce faire, nous devons augmenter la taille du nombre d'articles qui appellent à cette taille. Ce code modifié modifie uniquement la première ligne de la méthode principale, définit le nombre d'éléments et transmet la valeur 2500000000000000000 à la fonction Calloc.

#inclure
#inclure
int main()
int * pointer = (int *) calloc (25000000000000000000000, sizeof (int));
int a;
if (pointer == null)
printf ("Mémoire non allouée.\ n ");
autre
printf ("La mémoire a été allouée avec succès à l'aide de la fonction calloc.\ n ");
scanf ("% d", & a);
retour 0;

Le programme s'exécute avec succès lorsque nous exécutons le code, mais le calloc renvoie NULL, indiquant que le programme ne peut pas allouer la quantité de mémoire demandée.

Exemple 3

Dans cet exemple, nous demandons la contribution de l'utilisateur concernant le nombre d'éléments nécessaires pour stocker les blocs de mémoire. Les fichiers d'en-tête nécessaires sont inclus dans les deux premières lignes du fichier. La fonction principale principale () commence alors. Nous avons déclaré 4 variables de type entier dans la fonction principale, dont la première est une variable de type pointeur qui est principalement utilisée pour stocker la sortie de la fonction calloc. Les autres variables sont des entiers simples. Le client est invité à saisir le nombre d'éléments pour lesquels une allocation de mémoire est nécessaire pour la ligne suivante.

Pour l'allocation de taille de bloc de mémoire, nous utilisons la fonction de fonction pour obtenir la taille du type de données entier. L'entrée de type entier de l'utilisateur est obtenue à l'aide de la fonction ScanF. La sortie de la fonction calloc est ensuite vérifiée pour déterminer si elle a réussi ou non. Si le processus d'allocation de mémoire est réussi, les valeurs nuls ne sont pas renvoyées. Si le résultat est trouvé, nous affichons un message de réussite, puis utilisons une boucle pour inviter l'utilisateur à tous les marques sur tous les sujets.

#inclure
#inclure
int main()
int * pointeur;
int nements, marques;
int sum = 0;
printf ("Entrez le nombre d'éléments (données des sujets) requis:");
scanf ("% d", & nelements);
pointer = (int *) calloc (nelements, sizeof (int));
if (pointer == null)
printf ("Mémoire non allouée.\ n ");
sortie (0);
autre
printf ("La mémoire a été allouée avec succès à l'aide de la fonction calloc.\ n ");
pour (int i = 0; i < nElements; i++);
int marques = 0;

Nous afficherons le score global de l'utilisateur à l'aide de la variable d'allocation de mémoire. Par conséquent, nous demandons à l'utilisateur de saisir le nombre d'éléments ou de sujets pour lesquels une allocation de mémoire est nécessaire en premier lieu juste à cette fin. Une fois la mémoire allouée correctement, nous utilisons une variable de pointeur pour stocker les marques de sujet. Les marques de chaque sujet sont affichées plus tard dans la boucle pour la boucle, et la somme des marques est affichée à la fin en utilisant la boucle pour exécuter la fonction de somme.

printf ("Entrez les marques de sujet (% d):", i);
scanf ("% d", & marks);
pointeur [i] = marques;
printf ("Les sujets étudiants marquent \ n");
pour (int i = 0; i < nElements; ++i)
printf ("Subject% d - [% d] \ n", (i + 1), Poininyer [i]);
sum = sum + pointer [i];
printf ("total marques:% d", somme);

scanf ("% d%", & nelements);
retour 0;

Voici la sortie du code d'extrait ci-dessus:

Conclusion

Cet article montre la fonction de mémoire calloc en C en utilisant trois exemples différents mais simples. Les exemples élaborent que si l'espace mémoire est insuffisant, cette allocation de mémoire échoue et renvoie un pointeur nul, indiquant qu'il s'agissait d'une défaillance via la fonction calloc de C.