Det här ämnet kommer att diskutera hur man skapar dynamisk minnesallokering med funktionen calloc() i programmeringsspråket C. Innan vi går igenom begreppen, låt oss diskutera den dynamiska minnesallokeringen i C. Dynamiskt minne är en strukturprogrammeringsprocedur som tillåter användare att allokera minnet vid körning av ett program. Genom att använda dynamisk minnesallokering kan vi öka eller minska minnet under körningen av ett program. På så sätt undviker man slöseri med datorminne. En minnesallokering är uppdelad i två delar, malloc() och calloc() funktion.

A calloc() funktion är en fördefinierad biblioteksfunktion som står för sammanhängande minnesallokering . En calloc()-funktion används för att skapa flera block vid körning av ett program som har samma storlek i minnet. En calloc-funktion är definierad inuti stdlib.h header-fil. Den har två parametrar, nej. av block och storleken på varje block. När det dynamiska minnet allokeras med hjälp av calloc()-funktionen, returnerar det basadressen för det första blocket, och varje block initieras med 0. Och om minnet inte skapas, returnerar det en NULL-pekare.

Anta till exempel att vi vill skapa tre minnesblock med funktionen calloc() måste vi skicka två parametrar, ett antal block (3) och storleken på varje block (int, char, float, etc.) i byten. På så sätt skapar den tre block vars storlek är densamma inne i datorns minne.

Syntax

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

I ovanstående syntax har calloc()-funktionen två parametrar. Den första parametern definierar antal block och den andra parametern definierar storleken på varje block i minne. Storleken på blocken och cast_type kan vara i int, char, float, etc.

Lämna tillbaka : Den returnerar basadressen för det första blocket till variabeln ptr.

Program för att kontrollera dynamiskt minne allokeras med calloc()-funktionen

Låt oss skriva ett enkelt program för att kontrollera om det dynamiska minnet är allokerat i 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; } 

Produktion:

 Memory is created successfully 

Program för att demonstrera användningen av calloc()-funktionen

Låt oss överväga att skapa dynamisk minnesallokering med funktionen calloc() och lagra data i minnesblocken.

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 för att frigöra dynamisk minnesallokering med free() funktion

free() funktion: En free() funktion används för att frigöra det dynamiska minnet som skapas antingen calloc () eller malloc () funktion. Dessa tilldelade minnen kan inte frigöras till sina egna, och de kommer att existera till slutet av programmet. Så det är vårt ansvar att frigöra det minnet som kan återanvändas, och därför använder vi uttryckligen funktionen free() för att frigöra minnet.

Syntax

 free (ptr); 

Här är free() en funktion som frigör det allokerade minnet med hjälp av variabeln pointer ptr.

Låt oss överväga att skapa dynamisk minnesallokering med funktionen calloc() och sedan frigöra upptaget utrymme med funktionen free() i C-programmet.

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></=>