¿Cómo libero memoria en C?

Estoy escribiendo código que tiene muchas matrices de 1 y 2 dimensiones. Recibí “error: no se puede asignar la región” y creo que se debe a que se asignó demasiada memoria. Uso las funciones “malloc” y “free”, pero no estoy seguro de estar usándolas correctamente. ¿Quizás sabes dónde puedo ver buenos ejemplos de gestión de memoria en C?

así que… Solo trato de hacer que un algoritmo funcione y, por ahora, este código es solo una función tras otra…

//memory allocation for 1D arrays
buffer = malloc(num_items*sizeof(double));

//memory allocation for 2D arrays
double **cross_norm=(double**)malloc(150 * sizeof(double *));
for(i=0; i<150;i++)
    {
        cross_norm[i]=(double*)malloc(num_items*sizeof(double));
    }
    
    //code
Window(N, window_buffer);
STFTforBMP(buffer,N,f, window_buffer);
getMagnitude(buffer,f, N, magnitude);
calculateEnergy(flux,magnitude, f);
calculateExpectedEnergy(expected_flux, candidate_beat_period, downbeat_location, f);
calculateCrossCorrelation(cross, flux, expected_values, f);
findLargestCrossCorrelation(&cross_max, cross, f);
normalizeCrossCorrelation(cross_norm, &cross_max, cross, f);
    ...............

¿Cómo debo usar el free ¿función?

Tienes que free() la memoria asignada en orden inverso exacto de cómo se asignó usando malloc().

Tenga en cuenta que debe liberar la memoria solo después de que haya terminado con el uso de los punteros asignados.

Asignación de memoria para arreglos 1D:

    buffer = malloc(num_items*sizeof(double));

Desasignación de memoria para arreglos 1D:

    free(buffer);

Asignación de memoria para arreglos 2D:

    double **cross_norm=(double**)malloc(150 * sizeof(double *));
    for(i=0; i<150;i++)
    {
        cross_norm[i]=(double*)malloc(num_items*sizeof(double));
    }

Desasignación de memoria para arreglos 2D:

    for(i=0; i<150;i++)
    {
        free(cross_norm[i]);
    }

    free(cross_norm);

En realidad, no puede “liberar” memoria manualmente en C, en el sentido de que la memoria se libera del proceso de regreso al sistema operativo … cuando llama malloc(), el tiempo de ejecución de libc subyacente solicitará al sistema operativo una región de memoria. En Linux, esto se puede hacer a través de una llamada relativamente “pesada” como mmap(). Una vez que esta región de memoria se asigna a su programa, hay una configuración de lista enlazada llamada “almacén gratuito” que administra esta región de memoria asignada. Cuando usted llama malloc(), busca rápidamente en la tienda libre un bloque de memoria libre del tamaño solicitado. A continuación, ajusta la lista vinculada para reflejar que se ha extraído una parte de la memoria del grupo de memoria asignado originalmente. Cuando usted llama free() el bloque de memoria se vuelve a colocar en el almacén gratuito como un nodo de lista enlazada que indica que es un fragmento de memoria disponible.

Si solicita más memoria de la que se encuentra en la tienda gratuita, libc-runtime volverá a solicitar más memoria del sistema operativo hasta el límite de la capacidad del sistema operativo para asignar memoria para ejecutar procesos. Sin embargo, cuando libera memoria, no se devuelve al sistema operativo… por lo general, se recicla de nuevo en la tienda gratuita, donde puede ser utilizada nuevamente por otra llamada a malloc(). Por lo tanto, si realiza muchas llamadas a malloc() y free() con solicitudes de tamaño de memoria variable, podría, en teoría, causar una condición llamada “fragmentación de memoria”, donde hay suficiente espacio en el almacén gratuito para asignar el bloque de memoria solicitado, pero no suficiente contiguo espacio para el tamaño del bloque que ha solicitado. Así la llamada a malloc() falla, y está efectivamente “sin memoria” a pesar de que puede haber mucha memoria disponible como una cantidad total de bytes en la tienda libre.