Dans cet article, nous examinerons les calloc() fonction et comment elle peut être utilisée avec succès en C++.
Qu'est-ce que la fonction calloc() ?
Le fonction calloc() est une fonction d'allocation de mémoire en programmation C++. Il est utilisé pour allouer un bloc de mémoire pour un tableau ou un ensemble de variables. Le calloc() la fonction est comme la malloc() fonction, sauf qu'il définit également la mémoire allouée à zéro initialement. Cela garantit que la mémoire allouée est initialisée à une valeur connue, ce qui est utile lorsque vous travaillez avec des tableaux et des structures.
La syntaxe pour le fonction calloc() est comme suit:
annuler * calloc ( taille_t nmemb , taille_t taille )
La fonction prend deux arguments : nmemb et taille . Le nmemb L'argument spécifie le nombre d'éléments du tableau alloués, tandis que l'argument taille L'argument spécifie la taille de chaque élément en octets.
De plus, si l'allocation de mémoire réussit, le calloc() La fonction renvoie un pointeur nul, sinon elle renvoie un pointeur vers le début du bloc de mémoire nouvellement formé. Pour éviter les fuites de mémoire, la mémoire allouée par calloc() doit être retiré à l'aide de la gratuit() méthode une fois qu'elle n'est plus nécessaire.
Comment utiliser la fonction calloc() en C++ ?
Utiliser calloc() fonction en C++, suivez les étapes ci-dessous :
Étape 1: Inclure le fichier d'en-tête nécessaire pour calloc() fonction, qui est
Étape 2: Déclarez ensuite une variable de pointeur du type de données souhaité.
Étape 3: Après cela, utilisez le calloc() fonction pour allouer de la mémoire et l'initialiser à 0.
Étape 4: Utilisez la mémoire allouée selon les besoins.
Étape 5 : Une fois que vous avez fini d'utiliser la mémoire allouée, libérez-la à l'aide de la gratuit() fonction.
L'exemple suivant montre la calloc() Implémentation de la fonction en C++.
#include#include
en utilisant l'espace de noms std ;
entier principal ( ) {
entier * ptr ;
ptr = ( entier * ) calloc ( 6 , taille de ( entier ) ) ;
si ( ! ptr ) {
écoute << 'Échec de l'allocation de mémoire' ;
sortie ( 1 ) ;
}
écoute << 'Valeurs d'initialisation...' << fin
<< fin ;
pour ( entier je = 0 ; je < 6 ; je ++ ) {
ptr [ je ] = je * 3 ;
}
écoute << 'Valeurs initialisées.' << fin ;
pour ( entier je = 0 ; je < 6 ; je ++ ) {
écoute << * ( ptr + je ) << fin ;
}
gratuit ( ptr ) ;
retour 0 ;
}
Dans le code ci-dessus, un pointeur entier ptr est déclaré le premier. La mémoire est alors allouée pour 6 entiers en utilisant calloc(), la mémoire étant initialisée à 0. Le taillede(entier) La fonction est utilisée pour calculer la quantité de mémoire nécessaire pour stocker des entiers. L'allocation de mémoire est ensuite vérifiée pour les erreurs afin de garantir le succès. Sinon, le programme se termine et un message d'erreur s'affiche.
La mémoire allouée est ensuite initialisée à l'aide des nombres obtenus en multipliant 'je * 3' utilisant un pour boucle. Les valeurs conservées dans la mémoire allouée sont imprimées à l'aide d'une seconde boucle for et d'une arithmétique de pointeur avec *(ptr + i) . En fin de compte, la mémoire qui a été allouée dynamiquement est libérée en appelant le gratuit() fonction, qui arrête les fuites de mémoire. Comme signe que le programme s'est exécuté avec succès, il renvoie 0.
Sortir
Conclusion
En C++, le calloc() La fonction est utile pour allouer dynamiquement de la mémoire. Non seulement il alloue de la mémoire, mais il la met également à zéro, ce qui est utile lorsque vous travaillez avec des tableaux et des structures. Comprendre comment utiliser calloc() efficace est crucial pour éviter les fuites de mémoire et assurer le succès de l'exécution du programme. Les développeurs peuvent utiliser en toute sécurité le calloc() méthode dans leurs programmes C++ en suivant les instructions données dans cet article.