Ta tema bo obravnavala, kako ustvariti dinamično dodelitev pomnilnika s funkcijo calloc() v programskem jeziku C. Preden gremo skozi koncepte, se pogovorimo o dinamičnem dodeljevanju pomnilnika v C. Dinamični pomnilnik je postopek strukturnega programiranja, ki uporabnikom omogoča dodeljevanje pomnilnika med izvajanjem programa. Z dinamično dodelitvijo pomnilnika lahko med izvajanjem programa povečamo ali zmanjšamo pomnilnik. Na ta način se izogne izgubi pomnilnika računalnika. Dodelitev pomnilnika je razdeljena na dva dela, in sicer na funkcijo malloc() in calloc().
A funkcijo calloc(). je vnaprej določena knjižnična funkcija, ki pomeni dodeljevanje neprekinjenega pomnilnika . Funkcija calloc() se uporablja za ustvarjanje več blokov v času izvajanja programa, ki ima enako velikost v pomnilniku. Funkcija calloc je definirana znotraj stdlib.h naslovna datoteka. Ima dva parametra, št. blokov in velikost vsakega bloka. Ko je dinamični pomnilnik dodeljen s funkcijo calloc(), vrne osnovni naslov prvega bloka in vsak blok je inicializiran z 0. In če pomnilnik ni ustvarjen, vrne kazalec NULL.
Na primer, recimo, da želimo ustvariti tri bloke pomnilnika s funkcijo calloc(), moramo posredovati dva parametra, število blokov (3) in velikost vsakega bloka (int, char, float itd.) v bajt. Na ta način ustvari tri bloke, katerih velikost je enaka znotraj pomnilnika računalnika.
Sintaksa
ptr = (cast_type *) calloc ( number_of_blocks, size_of_block);
V zgornji sintaksi ima funkcija calloc() dva parametra. Prvi parameter določa število blokov in drugi parameter določa velikosti vsakega bloka v spomin. Velikost blokov in cast_type sta lahko v int, char, float itd.
Vrnitev : spremenljivki ptr vrne osnovni naslov prvega bloka.
vrstica proti stolpcu
Program za preverjanje dinamičnega pomnilnika se dodeli s funkcijo calloc().
Napišimo preprost program za preverjanje, ali je v C-ju dodeljen dinamični pomnilnik.
program.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; } Izhod:
Memory is created successfully
Program za predstavitev uporabe funkcije calloc().
Razmislimo o ustvarjanju dinamične dodelitve pomnilnika s funkcijo calloc() in shranjevanju podatkov v pomnilniške bloke.
Program2.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></=> Program za sprostitev dinamične dodelitve pomnilnika s funkcijo free().
funkcija free(): Funkcija free() se uporablja za sprostitev dinamičnega pomnilnika, ki je ustvarjen bodisi calloc () oz malloc () funkcijo. Teh dodeljenih pomnilnikov ni mogoče sprostiti sami in bodo obstajali do konca programa. Naša odgovornost je torej sprostiti ta pomnilnik, ki ga je mogoče ponovno uporabiti, zato izrecno uporabljamo funkcijo free() za sprostitev pomnilnika.
Sintaksa
c programi
free (ptr);
Tu je free() funkcija, ki sprosti dodeljeni pomnilnik z uporabo spremenljivke ptr kazalca.
Razmislimo o ustvarjanju dinamične dodelitve pomnilnika s funkcijo calloc() in nato sprostitvi zasedenega prostora s funkcijo free() v programu C.
Sprostitev.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></=>