Asignación de Memoria Dinámica en C: Funciones malloc(), calloc()

Antes de aprender la asignación de Memoria Dinámica en C, vamos a entender:

¿Cómo funciona la gestión de memoria en C?

Cuando declaras una variable utilizando un tipo de datos básico, el compilador de C asigna automáticamente espacio de memoria para la variable en un pool de memoria llamado pila.

Por ejemplo, una variable float suele ocupar 4 bytes (según la plataforma) cuando se declara. Podemos verificar esta información utilizando el operador sizeof como se muestra en el siguiente ejemplo

#include <stdio.h>int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

La salida será:

 The size of float is 4 bytes 

Además, un array con un tamaño especificado se asigna en bloques contiguos de memoria, cada bloque tiene el tamaño para un elemento:

#include <stdio.h>int main() { float arr;printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;} 

El resultado es:

 The size of the float array with 10 element is 40

Como se ha aprendido hasta ahora, al declarar un tipo de datos básico o un array, la memoria se gestiona automáticamente. Sin embargo, existe un proceso de asignación de memoria en C que te permitirá implementar un programa en el que el tamaño del array no se decida hasta que ejecutes tu programa (runtime). Este proceso se llama «Asignación dinámica de memoria».

En este tutorial, aprenderás-

• ¿Cómo funciona la gestión de memoria en C?
• La Asignación Dinámica de Memoria en C
• La Función C malloc()
• La Función free()
• La Función C calloc()
• Calloc() vs. malloc(): Diferencias clave
• La función realloc() de C
• Arrays dinámicos

Asignación de memoria dinámica en C

La asignación de memoria dinámica es la asignación y liberación manual de memoria según sus necesidades de programación. La memoria dinámica se gestiona y se sirve con punteros que apuntan al espacio de memoria recién asignado en una zona que llamamos heap.

Ahora puedes crear y destruir un array de elementos dinámicamente en tiempo de ejecución sin ningún problema. En resumen, la gestión automática de la memoria utiliza la pila, y la asignación dinámica de memoria en C utiliza el heap.

La librería <stdlib.h> tiene funciones responsables de la Gestión de Memoria Dinámica.

Función	Propósito
malloc()	Asigna la memoria de tamaño solicitado y devuelve el puntero al primer byte del espacio asignado.
calloc()	Asigna el espacio para los elementos de un array. Inicializa los elementos a cero y devuelve un puntero a la memoria.
realloc()	Se utiliza para modificar el tamaño del espacio de memoria previamente asignado.
Free()	Libera o vacía el espacio de memoria previamente asignado.

Discutiremos las funciones anteriores con su aplicación

Función C malloc()

La función C malloc() representa la asignación de memoria. Es una función que se utiliza para asignar un bloque de memoria dinámicamente. Reserva un espacio de memoria de tamaño especificado y devuelve el puntero nulo que apunta a la ubicación de memoria. El puntero devuelto suele ser de tipo void. Esto significa que podemos asignar la función C malloc() a cualquier puntero.

Sintaxis de la función malloc():

ptr = (cast_type *) malloc (byte_size);

Aquí,

Ejemplo de malloc():

Example: ptr = (int *) malloc (50)

Cuando esta sentencia se ejecuta con éxito, se reserva un espacio de memoria de 50 bytes. La dirección del primer byte del espacio reservado se asigna al puntero ptr de tipo int.

Considere otro ejemplo:

#include <stdlib.h>int main(){int *ptr;ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */ if (ptr != NULL) { *(ptr + 5) = 480; /* assign 480 to sixth integer */ printf("Value of the 6th integer is %d",*(ptr + 5)); }}

Salida:

Value of the 6th integer is 480

La función Malloc() también se puede utilizar con el tipo de datos de caracteres así como con tipos de datos complejos como las estructuras.

Por ejemplo:

#include <stdio.h>int main() {int* ptr = malloc(10 * sizeof(*ptr));if (ptr != NULL){ *(ptr + 2) = 50; printf("Value of the 2nd integer is %d",*(ptr + 2));}free(ptr);}

Salida

 Value of the 2nd integer is 50

Sintaxis de la función calloc():

ptr = (cast_type *) calloc (n, size);

• La sentencia anterior se utiliza para asignar n bloques de memoria del mismo tamaño.
• Después de asignar el espacio de memoria, entonces todos los bytes se inicializan a cero.
• Se devuelve el puntero que está actualmente en el primer byte del espacio de memoria asignado.

Siempre que haya un error al asignar el espacio de memoria, como la escasez de memoria, entonces se devuelve un puntero nulo.

Ejemplo de calloc():

El programa siguiente calcula la suma de una secuencia aritmética.

#include <stdio.h> int main() { int i, * ptr, sum = 0; ptr = calloc(10, sizeof(int)); if (ptr == NULL) { printf("Error! memory not allocated."); exit(0); } printf("Building and calculating the sequence sum of the first 10 terms \ n "); for (i = 0; i < 10; ++i) { * (ptr + i) = i; sum += * (ptr + i); } printf("Sum = %d", sum); free(ptr); return 0; }

Resultado:

 Building and calculating the sequence sum of the first 10 termsSum = 45

calloc() vs. malloc(): Diferencias clave

A continuación se muestra la diferencia clave entre malloc() Vs calloc() en C:

La función calloc() es generalmente más adecuada y eficiente que la de la función malloc(). Mientras que ambas funciones se utilizan para asignar espacio de memoria, calloc() puede asignar múltiples bloques de una sola vez. No es necesario solicitar un bloque de memoria cada vez. La función calloc() se utiliza en estructuras de datos complejas que requieren un mayor espacio de memoria.

El bloque de memoria asignado por un calloc() en C siempre se inicializa a cero mientras que en la función malloc() en C, siempre contiene un valor basura.

Sintaxis de la función realloc():

ptr = realloc (ptr,newsize);

La sentencia anterior asigna un nuevo espacio de memoria con un tamaño especificado en la variable newsize. Después de ejecutar la función, el puntero será devuelto al primer byte del bloque de memoria. El nuevo tamaño puede ser mayor o menor que la memoria anterior. No podemos estar seguros de que si el bloque recién asignado apuntará a la misma ubicación que la del bloque de memoria anterior. Esta función copiará todos los datos anteriores en la nueva región. Esto asegura que los datos permanecerán seguros.

Ejemplo de realloc():

#include <stdio.h>int main () { char *ptr; ptr = (char *) malloc(10); strcpy(ptr, "Programming"); printf(" %s, Address = %u\n", ptr, ptr); ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size strcat(ptr, " In 'C'"); printf(" %s, Address = %u\n", ptr, ptr); free(ptr); return 0;} 

Cuando la función realloc() en C resulta en una operación fallida, devuelve un puntero nulo, y los datos anteriores también son liberados.

#include <stdio.h> int main() { int * arr_dynamic = NULL; int elements = 2, i; arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks for (i = 0; i < elements; i++) arr_dynamic = i; for (i = 0; i < elements; i++) printf("arr_dynamic=%d\n", i, arr_dynamic); elements = 4; arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elements printf("After realloc\n"); for (i = 2; i < elements; i++) arr_dynamic = i; for (i = 0; i < elements; i++) printf("arr_dynamic=%d\n", i, arr_dynamic); free(arr_dynamic); } 

 arr_dynamic=0arr_dynamic=1After reallocarr_dynamic=0arr_dynamic=1arr_dynamic=2arr_dynamic=3