In questo argomento verrà illustrato come creare un'allocazione dinamica della memoria utilizzando la funzione calloc() nel linguaggio di programmazione C. Prima di esaminare i concetti, discutiamo dell'allocazione dinamica della memoria in C. La memoria dinamica è una procedura di programmazione della struttura che consente agli utenti di allocare la memoria durante l'esecuzione di un programma. Utilizzando l'allocazione dinamica della memoria, possiamo aumentare o diminuire la memoria durante l'esecuzione di un programma. In questo modo si evita lo spreco di memoria del computer. Un'allocazione di memoria è divisa in due parti: la funzione malloc() e calloc().

UN funzione calloc() è una funzione di libreria predefinita che sta per allocazione di memoria contigua . Una funzione calloc() viene utilizzata per creare più blocchi in fase di esecuzione di un programma avente la stessa dimensione in memoria. Una funzione calloc è definita all'interno del file stdlib.h file di intestazione. Ha due parametri, no. di blocchi e la dimensione di ciascun blocco. Quando la memoria dinamica viene allocata utilizzando la funzione calloc(), restituisce l'indirizzo di base del primo blocco e ciascun blocco viene inizializzato con 0. E se la memoria non viene creata, restituisce un puntatore NULL.

inversione delle corde in c

Ad esempio, supponiamo di voler creare tre blocchi di memoria utilizzando la funzione calloc(), dobbiamo passare due parametri, un numero di blocchi (3) e la dimensione di ciascun blocco (int, char, float, ecc.) in il byte. In questo modo crea tre blocchi di dimensioni identiche all'interno della memoria del computer.

Sintassi

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

Nella sintassi precedente, la funzione calloc() ha due parametri. Il primo parametro definisce il numero di blocchi e il secondo parametro definisce il dimensione di ciascun blocco in memoria. La dimensione dei blocchi e cast_type può essere int, char, float, ecc.

Ritorno : Restituisce l'indirizzo base del primo blocco alla variabile ptr.

Il programma per verificare l'allocazione della memoria dinamica utilizzando la funzione calloc()

Scriviamo un semplice programma per verificare se la memoria dinamica è allocata in C.

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

Produzione:

 Memory is created successfully 

Programma per dimostrare l'uso della funzione calloc()

Consideriamo la creazione di un'allocazione dinamica della memoria utilizzando la funzione calloc() e la memorizzazione dei dati nei blocchi di memoria.

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

Programma per rilasciare l'allocazione dinamica della memoria utilizzando la funzione free()

funzione libera(): Una funzione free() viene utilizzata per rilasciare la memoria dinamica che viene creata calloc () O malloc () funzione. Queste memorie assegnate non possono essere liberate e esisteranno fino alla fine del programma. Quindi, è nostra responsabilità rilasciare quella memoria che può essere riutilizzata, e quindi utilizziamo esplicitamente la funzione free() per rilasciare la memoria.

Sintassi

 free (ptr); 

Qui free() è una funzione che rilascia la memoria allocata utilizzando la variabile puntatore ptr.

Consideriamo la creazione di un'allocazione dinamica della memoria utilizzando la funzione calloc() e quindi il rilascio dello spazio occupato utilizzando la funzione free() nel programma C.

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