Función gratuita en lenguaje C

En la asignación dinámica, un espacio de memoria de cierto tamaño está reservado en tiempo de ejecución para uso exclusivo por el proceso que lo asigna.

El lenguaje C tiene varias funciones complementarias para la gestión de la memoria dinámica. Los más comúnmente implementados son MALLOC (), REALLOC () y Free () que son parte de la biblioteca estándar y se definen en el "STDLIB.encabezado. Estas tres funciones asignan la memoria a un proceso, cambian su tamaño y la liberan nuevamente.

En la programación, es muy importante administrar estrictamente la memoria dinámica porque cada vez que asignamos los recursos a un programa, los llevamos del sistema operativo. La mala gestión de la memoria dinámica puede tener consecuencias catastróficas para los procesos que se ejecutan en el sistema en ese momento.

En este artículo de Sugerencia de Linux, aprenderá cómo usar la función Free (), que es una de las tres funciones básicas que el lenguaje C proporciona para la gestión de la memoria dinámica que libera los recursos asignados y los devuelve al sistema operativo para reutilizar.

Le mostraremos la sintaxis y la descripción de cómo funciona, el argumento de entrada y el tipo de datos que lo compensa. Luego, implementaremos el uso de la función libre () en ejemplos prácticos con fragmentos e imágenes de código que demuestran su uso y sus efectos en el sistema.

Sintaxis de la función Free () en el lenguaje C

sin vacío (void *ptr);

Descripción de la función Free () en el lenguaje C

La función libre () libera una cantidad especificada de memoria asignada dinámicamente.

La memoria dinámica se asigna llamando a la función malloc () y especificando el tamaño en los bytes del área que desea asignar en su argumento de entrada. Como resultado, esta función devuelve el puntero "PTR" que apunta al área recién asignada.

La función Free () libera el espacio de memoria reservado al que hace referencia "PTR" en su argumento de entrada única y devuelve su disponibilidad al sistema operativo. Esta función no devuelve resultados y no tiene definición de error en el "Errno.H " encabezamiento.

La función libre () es parte de la biblioteca estándar y se define en el "Stdlib.H " encabezamiento. Para usarlo y las otras funciones de administración de memoria dinámica, debe incluir este encabezado en su código de la siguiente manera:

#incluir

Cómo liberar la memoria asignada dinámicamente usando la función Free ()

En este ejemplo, creamos una aplicación de consola muy simple que nos da control sobre la asignación de la memoria con la función malloc () y liberando la memoria con la función libre (). Luego compilamos el código y ejecutamos la aplicación, monitoreamos el sistema y observamos los efectos.

Para crear la aplicación de la consola, primero incluimos los encabezados requeridos y abrimos una función Main () con una devolución vacía. Declaramos el puntero de "PTR" que se usa en las funciones malloc () y free () para los punteros a las áreas de memoria asignadas. También declaramos el tamaño entero que determina el tamaño de la memoria asignada, y la opción entera, que es la condición del interruptor que usamos para seleccionar la opción de menú.

Una vez que se declaran las variables requeridas, la aplicación muestra su PID utilizando las funciones printf () y getPID (). Luego, el programa ingresa a un bucle infinito donde muestra un menú con dos opciones. El elemento seleccionado por el usuario se recupera utilizando la función scanf () en la opción entera y es la condición para un interruptor con dos casos, uno para cada opción.

La opción 1 llama a la función malloc () que asigna un bloque de memoria de 122 MB al proceso. Mientras que la opción 2 libera ese bloque llamando a la función libre (). Puede ver el código completo de esta aplicación en la siguiente ilustración:

#incluir
#incluir
#incluir
#incluir
vacío principal()

opción int;
char *ptr;
tamaño int = 64000000;
printf ("\ nprocess id: %i \ n", getpid ());
mientras (1)
printf ("\ n [1] asignar memoria.\ n [2] Memoria de liberación.\norte");
scanf ("%i", y opción);
Switch (opción)
caso 1:
printf ("\ nallocating Memory ... \ n");
Ptr = malloc (size*sizeOf (char));
romper;
Caso 2:
printf ("\ nReleing Memory ... \ n");
gratis (PTR);
romper;
// interruptor final
// finalizar mientras (1)

Tenga en cuenta que en el caso 1, la función malloc () asigna un área de memoria de tamaño y devuelve el puntero "PTR". En el caso 2, la función libre () utiliza el mismo puntero que el argumento de entrada para liberar la memoria asignada.

Para ver los efectos de estas dos funciones en el sistema, necesitamos abrir dos consolas de comando. En la terminal 1, ejecutamos el comando superior para ver los recursos utilizados por cada proceso del sistema. En la terminal 2, compilamos y ejecutamos la aplicación que acabamos de ver.

Una vez que la aplicación se está ejecutando, observamos la consola 1 para obtener los recursos que utilizan el proceso cuyo PID se muestra en la consola 2.

Como podemos ver en la figura, el sistema asignó el número de PID 13009 al proceso. Podemos ver en la columna 10 del terminal izquierdo que nuestra aplicación consume menos de 0.1% de la memoria del sistema.

Si seleccionamos la opción 1 de nuestra aplicación y presionamos "ENTER", la función MALLOC () asigna 122 MB de memoria al proceso.

Como podemos ver en esta imagen, la memoria utilizada por nuestra aplicación ahora es 3.6% de la memoria total que está disponible en el sistema.

Ahora, seleccionamos la opción 2 de nuestra aplicación que llama a la función Free (), pasando el puntero "PTR" como argumento de entrada. Esta acción libera la memoria asignada por la función malloc () en la opción 1.

En esta imagen, podemos ver cómo la función libre () liberó la memoria asignada de 3.6% a 0.1% del sistema total utilizado por nuestra aplicación.

Conclusión

En este artículo de Sugerencia de Linux, le mostramos cómo usar la función gratuita () para liberar la memoria asignada dinámicamente. Miramos la sintaxis de esta función y la descripción teórica de cómo funciona.

Luego, aplicamos lo que aprendimos en un ejemplo práctico con fragmentos e imágenes de código donde creamos una aplicación de consola que controla la llamada de las funciones MALLOC () y Free (). Lo ejecutamos paso a paso y monitoreamos el sistema para ver los efectos de llamar a las funciones para asignar y liberar la memoria del sistema.