Wie gebe ich Speicher in C frei?

Ich schreibe Code, der viele 1- und 2-dimensionale Arrays enthält. Ich habe “Fehler: Region kann nicht zugewiesen werden” erhalten, und ich denke, es liegt daran, dass zu viel Speicher zugewiesen ist. Ich verwende die Funktionen “malloc” und “free”, bin mir aber nicht sicher, ob ich sie richtig verwende. Vielleicht wissen Sie, wo ich gute Beispiele zur Speicherverwaltung in C sehen könnte?

Also .. Ich versuche nur, einen Algorithmus zum Laufen zu bringen, und im Moment ist dieser Code nur eine Funktion nach der anderen.

//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);
    ...............

Wie soll ich die verwenden free Funktion?

Sie müssen free() den zugewiesenen Speicher in genau umgekehrter Reihenfolge wie er zugewiesen wurde malloc().

Beachten Sie, dass Sie den Speicher erst freigeben sollten, nachdem Sie mit der Verwendung der zugewiesenen Zeiger fertig sind.

Speicherzuordnung für 1D-Arrays:

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

Speicherfreigabe für 1D-Arrays:

    free(buffer);

Speicherzuweisung für 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));
    }

Speicherfreigabe für 2D-Arrays:

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

    free(cross_norm);

Sie können Speicher in C tatsächlich nicht manuell “freigeben”, in dem Sinne, dass der Speicher vom Prozess zurück an das Betriebssystem freigegeben wird … wenn Sie anrufen malloc(), fordert die zugrunde liegende libc-runtime vom Betriebssystem einen Speicherbereich an. Unter Linux kann dies jedoch ein relativ “schwerer” Aufruf sein mmap(). Sobald dieser Speicherbereich Ihrem Programm zugeordnet ist, gibt es ein Linked-List-Setup namens “Free Store”, das diesen zugewiesenen Speicherbereich verwaltet. Wenn du anrufst malloc(), sucht es schnell im Free-Store nach einem freien Speicherblock in der angeforderten Größe. Dann passt es die verkettete Liste an, um widerzuspiegeln, dass ein Teil des Speichers aus dem ursprünglich zugewiesenen Speicherpool genommen wurde. Wenn du anrufst free() der Speicherblock wird als Knoten einer verketteten Liste zurück in den freien Speicher gestellt, was anzeigt, dass es sich um ein verfügbares Stück Speicher handelt.

Wenn Sie mehr Speicher anfordern, als sich im Free-Store befindet, fordert die libc-runtime erneut mehr Speicher vom Betriebssystem an, bis das Betriebssystem Speicher für laufende Prozesse zuweisen kann. Wenn Sie Speicher freigeben, wird er jedoch nicht an das Betriebssystem zurückgegeben … er wird normalerweise in den Free-Store zurückgeführt, wo er von einem anderen Aufruf wieder verwendet werden kann malloc(). Also, wenn man viel telefoniert malloc() und free() Bei unterschiedlichen Anforderungen an die Speichergröße könnte dies theoretisch einen Zustand namens “Speicherfragmentierung” verursachen, bei dem im Free-Store genügend Speicherplatz vorhanden ist, um den angeforderten Speicherblock zuzuweisen, aber nicht genug zusammenhängend Platz für die Größe des angeforderten Blocks. Daher der Aufruf an malloc() schlägt fehl, und Sie haben effektiv “out-of-memory”, obwohl möglicherweise viel Speicher als Gesamtmenge an Bytes im Free-Store verfügbar ist.