Táto téma bude diskutovať o tom, ako vytvoriť dynamickú alokáciu pamäte pomocou funkcie calloc() v programovacom jazyku C. Predtým, než prejdeme cez koncepty, poďme diskutovať o dynamickej alokácii pamäte v C. Dynamická pamäť je procedúra programovania štruktúry, ktorá umožňuje používateľom alokovať pamäť v čase behu programu. Pomocou dynamickej alokácie pamäte môžeme pamäť zväčšiť alebo zmenšiť počas vykonávania programu. Týmto spôsobom sa zabráni plytvaniu počítačovou pamäťou. Alokácia pamäte je rozdelená na dve časti, ktorými sú funkcia malloc() a calloc().

A funkciu calloc(). je preddefinovaná funkcia knižnice, ktorá znamená súvislá alokácia pamäte . Funkcia calloc() sa používa na vytvorenie viacerých blokov v čase spustenia programu s rovnakou veľkosťou v pamäti. Vo vnútri je definovaná funkcia calloc stdlib.h hlavičkový súbor. Má dva parametre, č. blokov a veľkosť každého bloku. Keď je dynamická pamäť alokovaná pomocou funkcie calloc(), vráti základnú adresu prvého bloku a každý blok je inicializovaný 0. A ak pamäť nie je vytvorená, vráti ukazovateľ NULL.

java typeof premennej

Predpokladajme napríklad, že chceme vytvoriť tri bloky pamäte pomocou funkcie calloc(), potrebujeme odovzdať dva parametre, počet blokov (3) a veľkosť každého bloku (int, char, float atď.) bajt. Týmto spôsobom vytvorí tri bloky, ktorých veľkosť je vo vnútri pamäte počítača rovnaká.

Syntax

 ptr = (cast_type *) calloc ( number_of_blocks, size_of_block); 

Vo vyššie uvedenej syntaxi má funkcia calloc() dva parametre. Prvý parameter definuje počet blokov a druhý parameter definuje veľkosť každého bloku v pamäti. Veľkosť blokov a cast_type môže byť int, char, float atď.

java matematický pow

Návrat : Vráti základnú adresu prvého bloku do premennej ptr.

Program na kontrolu dynamickej pamäte je alokovaný pomocou funkcie calloc().

Napíšme jednoduchý program na kontrolu, či je dynamická pamäť alokovaná v C.

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; } 

Výkon:

 Memory is created successfully 

Program na demonštráciu použitia funkcie calloc().

Uvažujme o vytvorení dynamickej alokácie pamäte pomocou funkcie calloc() a ukladaní údajov do pamäťových blokov.

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 
&apos;, 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&apos;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 (&apos; Define the number of elements to be entered: &apos;); scanf (&apos; %d&apos;, &amp;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 (&apos; Out of memory &apos;); exit(0); } printf (&apos; Enter the elements 
&apos;, 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 na uvoľnenie dynamickej alokácie pamäte pomocou funkcie free().

funkcia free(): Funkcia free() sa používa na uvoľnenie dynamickej pamäte, ktorá je tiež vytvorená calloc () alebo malloc () funkcia. Tieto pridelené pamäte nemožno uvoľniť pre svoje vlastné a budú existovať až do konca programu. Takže je našou zodpovednosťou uvoľniť tú pamäť, ktorá môže byť znovu použitá, a preto explicitne používame funkciu free() na uvoľnenie pamäte.

np priemer

Syntax

 free (ptr); 

Tu je free() funkcia, ktorá uvoľňuje pridelenú pamäť pomocou premennej pointer ptr.

pole slicing java

Uvažujme o vytvorení dynamickej alokácie pamäte pomocou funkcie calloc() a následnom uvoľnení obsadeného priestoru pomocou funkcie free() v programe C.

Release.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 
&apos;, 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></=>