Cette rubrique explique comment créer une allocation dynamique de mémoire à l'aide de la fonction calloc() dans le langage de programmation C. Avant de passer en revue les concepts, discutons de l'allocation dynamique de mémoire en C. La mémoire dynamique est une procédure de programmation structurelle qui permet aux utilisateurs d'allouer de la mémoire au moment de l'exécution d'un programme. Grâce à l'allocation dynamique de mémoire, nous pouvons augmenter ou diminuer la mémoire lors de l'exécution d'un programme. De cette façon, cela évite le gaspillage de la mémoire de l’ordinateur. Une allocation de mémoire est divisée en deux parties : les fonctions malloc() et calloc().
UN Fonction calloc() est une fonction de bibliothèque prédéfinie qui signifie allocation de mémoire contiguë . Une fonction calloc() est utilisée pour créer plusieurs blocs au moment de l'exécution d'un programme ayant la même taille en mémoire. Une fonction calloc est définie à l'intérieur du stdlib.h En tête de fichier. Il a deux paramètres, non. de blocs et la taille de chaque bloc. Lorsque la mémoire dynamique est allouée à l'aide de la fonction calloc(), elle renvoie l'adresse de base du premier bloc, et chaque bloc est initialisé à 0. Et si la mémoire n'est pas créée, elle renvoie un pointeur NULL.
fonction lambda java
Par exemple, supposons que nous voulions créer trois blocs de mémoire à l'aide de la fonction calloc(), nous devons passer deux paramètres, un nombre de blocs (3) et la taille de chaque bloc (int, char, float, etc.) l'octet. De cette façon, il crée trois blocs dont la taille est la même dans la mémoire de l'ordinateur.
Syntaxe
ptr = (cast_type *) calloc ( number_of_blocks, size_of_block);
Dans la syntaxe ci-dessus, la fonction calloc() a deux paramètres. Le premier paramètre définit le nombre de blocs et le deuxième paramètre définit le taille de chaque bloc en mémoire. La taille des blocs et cast_type peut être en int, char, float, etc.
tutoriels Java
Retour : Il renvoie l'adresse de base du premier bloc à la variable ptr.
Le programme pour vérifier que la mémoire dynamique est allouée à l'aide de la fonction calloc()
Écrivons un programme simple pour vérifier si la mémoire dynamique est allouée en C.
programme.c
#include #include int main() { int *ptr; /* use calloc() function to define the no. of blocks and size of each blocks. */ ptr = calloc (4, sizeof(int)); // here 4 is the no. of block and int is the size of block if (ptr != NULL) { printf (' Memory is created successfully
'); } else printf (' Memory is not created '); return 0; } Sortir:
Memory is created successfully
Programme pour démontrer l'utilisation de la fonction calloc()
Envisageons de créer une allocation dynamique de mémoire à l'aide de la fonction calloc() et de stocker les données dans les blocs de mémoire.
Programme2.c
#include #include #include void main() { int n, *ptr, *p, i, sum = 0; /* n = number of elements, *ptr = store base address of the dynamic memory, *p store temporary address of the *ptr */ printf (' Enter the number of elements: '); scanf (' %d', &n); // it takes number of elements // use calloc syntax to create memory block of int data type ptr = (int *) calloc (n, sizeof(int)); p = ptr; // assign the address of ptr if (ptr == NULL) // it checks whether the memory is allocated { printf (' Memory is not allocated. '); exit(0); // exit from the program } printf (' Enter %d numbers
', n); for ( i = 1; i <= n; i++) { scanf ( '%d', ptr); sum="sum" + *ptr; ptr++; } printf (' elements are: '); for (i="1;" i <="n;" %d', *p); p++;
the addition of is: %d ', sum); getch(); pre> <p> <strong>Output:</strong> </p> <pre> Enter the number of elements: 5 Enter 5 numbers 1 2 3 4 5 Elements are: 1 2 3 4 5 The addition of the elements is: 15 </pre> <h3>Program to release dynamic memory allocation using free() function</h3> <p> <strong>free() function:</strong> A free() function is used to release the dynamic memory which is created either <strong>calloc</strong> () or <strong>malloc</strong> () function. These allocated memories cannot be freed to their own, and they will exist till the end of the program. So, it is our responsibility to release that memory that can be reused, and hence we explicitly use the free() function to release the memory.</p> <p> <strong>Syntax</strong> </p> <pre> free (ptr); </pre> <p>Here free() is a function that releases the allocated memory using the pointer ptr variable.</p> <p>Let's consider creating dynamic memory allocation using the calloc() function and then releasing occupied space using the free() function in the C program.</p> <p> <strong>Release.c</strong> </p> <pre> #include #include #include void main() { int n, *ptr, *p, i, sum = 0; printf (' Define the number of elements to be entered: '); scanf (' %d', &n); // use calloc syntax to create memory block of int data type ptr = (int *) calloc (n, sizeof(int)); p = ptr; // store the base address in p if (ptr == NULL) { printf (' Out of memory '); exit(0); } printf (' Enter the elements
', n); for ( i = 1; i <= n; i++) { scanf ( '%d', ptr); sum="sum" + *ptr; ptr++; } printf (' elements are: '); for (i="1;" i <="n;" %d', *p); p++;
the addition of is: %d ', sum); free(ptr); * use free() function to release dynamic memory allocation getch(); pre> <p> <strong>Output:</strong> </p> <pre> Define the number of elements to be entered: 6 Enter the elements 2 4 6 8 10 12 Elements are: 2 4 6 8 10 12 The addition of the elements is: 42 </pre> <hr></=></pre></=> Programme pour libérer l'allocation dynamique de mémoire à l'aide de la fonction free()
Fonction free() : Une fonction free() permet de libérer la mémoire dynamique qui est créée soit calloc () ou malloc () fonction. Ces mémoires allouées ne peuvent pas être libérées et elles existeront jusqu'à la fin du programme. Il est donc de notre responsabilité de libérer cette mémoire qui peut être réutilisée, et nous utilisons donc explicitement la fonction free() pour libérer la mémoire.
chaîne java
Syntaxe
free (ptr);
Ici, free() est une fonction qui libère la mémoire allouée à l'aide de la variable pointeur ptr.
définir Java
Envisageons de créer une allocation dynamique de mémoire à l'aide de la fonction calloc(), puis de libérer l'espace occupé à l'aide de la fonction free() dans le programme C.
Libération.c
#include #include #include void main() { int n, *ptr, *p, i, sum = 0; printf (' Define the number of elements to be entered: '); scanf (' %d', &n); // use calloc syntax to create memory block of int data type ptr = (int *) calloc (n, sizeof(int)); p = ptr; // store the base address in p if (ptr == NULL) { printf (' Out of memory '); exit(0); } printf (' Enter the elements
', n); for ( i = 1; i <= n; i++) { scanf ( \'%d\', ptr); sum="sum" + *ptr; ptr++; } printf (\' elements are: \'); for (i="1;" i <="n;" %d\', *p); p++;
the addition of is: %d \', sum); free(ptr); * use free() function to release dynamic memory allocation getch(); pre> <p> <strong>Output:</strong> </p> <pre> Define the number of elements to be entered: 6 Enter the elements 2 4 6 8 10 12 Elements are: 2 4 6 8 10 12 The addition of the elements is: 42 </pre> <hr></=>