Aquest tema tractarà com crear una assignació de memòria dinàmica mitjançant la funció calloc() en el llenguatge de programació C. Abans de passar pels conceptes, parlem de l'assignació de memòria dinàmica en C. La memòria dinàmica és un procediment de programació d'estructura que permet als usuaris assignar la memòria en el temps d'execució d'un programa. Mitjançant l'assignació de memòria dinàmica, podem augmentar o disminuir la memòria durant l'execució d'un programa. D'aquesta manera, s'evita el malbaratament de la memòria de l'ordinador. Una assignació de memòria es divideix en dues parts: la funció malloc() i calloc().
A funció calloc(). és una funció de biblioteca predefinida que significa assignació de memòria contigua . Una funció calloc() s'utilitza per crear diversos blocs en temps d'execució d'un programa que tingui la mateixa mida a la memòria. Una funció calloc es defineix dins de stdlib.h fitxer de capçalera. Té dos paràmetres, no. de blocs i la mida de cada bloc. Quan la memòria dinàmica s'assigna mitjançant la funció calloc(), retorna l'adreça base del primer bloc, i cada bloc s'inicialitza amb 0. I si no es crea memòria, retorna un punter NULL.
comanda sed
Per exemple, suposem que volem crear tres blocs de memòria amb la funció calloc(), hem de passar dos paràmetres, un nombre de blocs (3) i la mida de cada bloc (int, char, float, etc.) el byte. D'aquesta manera, crea tres blocs la mida dels quals és la mateixa dins la memòria de l'ordinador.
Sintaxi
ptr = (cast_type *) calloc ( number_of_blocks, size_of_block);
A la sintaxi anterior, la funció calloc() té dos paràmetres. El primer paràmetre defineix el nombre de blocs i el segon paràmetre defineix el mida de cada bloc en memòria. La mida dels blocs i cast_type pot ser en int, char, float, etc.
Tornar : retorna l'adreça base del primer bloc a la variable ptr.
El programa per comprovar la memòria dinàmica s'assigna mitjançant la funció calloc().
Escrivim un programa senzill per comprovar si la memòria dinàmica està assignada en C.
programa.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; } Sortida:
Memory is created successfully
Programa per demostrar l'ús de la funció calloc().
Considerem la creació d'una assignació de memòria dinàmica mitjançant la funció calloc() i l'emmagatzematge de dades als blocs de memòria.
Programa 2.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></=> Programa per alliberar l'assignació de memòria dinàmica mitjançant la funció free().
funció free(): S'utilitza una funció free() per alliberar la memòria dinàmica que es crea calloc () o malloc () funció. Aquestes memòries assignades no es poden alliberar per elles mateixes i existiran fins al final del programa. Per tant, és la nostra responsabilitat alliberar aquesta memòria que es pugui reutilitzar i, per tant, fem servir explícitament la funció free() per alliberar la memòria.
Sintaxi
free (ptr);
Aquí free() és una funció que allibera la memòria assignada mitjançant la variable punter ptr.
Considerem la creació d'una assignació de memòria dinàmica mitjançant la funció calloc() i després alliberar l'espai ocupat mitjançant la funció free() del programa C.
"què" és 10 de 100?
Alliberament.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></=>