Este tema discutirá cómo crear una asignación de memoria dinámica usando la función calloc() en el lenguaje de programación C. Antes de analizar los conceptos, analicemos la asignación de memoria dinámica en C. La memoria dinámica es un procedimiento de programación de estructuras que permite a los usuarios asignar la memoria en el tiempo de ejecución de un programa. Usando la asignación de memoria dinámica, podemos aumentar o disminuir la memoria durante la ejecución de un programa. De esta forma se evita el desperdicio de memoria del ordenador. Una asignación de memoria se divide en dos partes: la función malloc() y calloc().

A función calloc() es una función de biblioteca predefinida que significa asignación de memoria contigua . Una función calloc() se utiliza para crear múltiples bloques en el tiempo de ejecución de un programa que tiene el mismo tamaño en la memoria. Una función calloc se define dentro del stdlib.h archivo de cabecera. Tiene dos parámetros, no. de bloques y el tamaño de cada bloque. Cuando la memoria dinámica se asigna usando la función calloc(), devuelve la dirección base del primer bloque y cada bloque se inicializa con 0. Y si no se crea memoria, devuelve un puntero NULL.

Por ejemplo, supongamos que queremos crear tres bloques de memoria usando la función calloc(), necesitamos pasar dos parámetros, una cantidad de bloques (3) y el tamaño de cada bloque (int, char, float, etc.) en el byte. De esta forma, crea tres bloques del mismo tamaño dentro de la memoria del ordenador.

Sintaxis

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

En la sintaxis anterior, la función calloc() tiene dos parámetros. El primer parámetro define el numero de bloques y el segundo parámetro define el tamaño de cada bloque en memoria. El tamaño de los bloques y cast_type puede estar en int, char, float, etc.

Devolver : Devuelve la dirección base del primer bloque a la variable ptr.

El programa para comprobar la asignación de memoria dinámica utiliza la función calloc()

Escribamos un programa simple para verificar si la memoria dinámica está asignada en C.

programa.c

mejores autos del mundo

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

Producción:

 Memory is created successfully 

Programa para demostrar el uso de la función calloc()

Consideremos crear una asignación de memoria dinámica usando la función calloc() y almacenar datos en los bloques de memoria.

lista enlazada java

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

Programa para liberar la asignación de memoria dinámica usando la función free()

función libre(): Se utiliza una función free() para liberar la memoria dinámica que se crea calloc () o malloc () función. Estas memorias asignadas no se pueden liberar por sí solas y existirán hasta el final del programa. Por lo tanto, es nuestra responsabilidad liberar esa memoria que pueda reutilizarse y, por lo tanto, usamos explícitamente la función free() para liberar la memoria.

Sintaxis

 free (ptr); 

Aquí free() es una función que libera la memoria asignada usando la variable de puntero ptr.

Consideremos crear una asignación de memoria dinámica usando la función calloc() y luego liberar el espacio ocupado usando la función free() en el programa C.

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