Woher weiß frei, wie viel freizugeben ist?

In der C-Programmierung können Sie jeden beliebigen Zeiger als Argument an free übergeben, woher weiß er die Größe des zugewiesenen Speichers, der freigegeben werden soll? Immer wenn ich einen Zeiger an eine Funktion übergebe, muss ich auch die Größe übergeben (dh ein Array mit 10 Elementen muss 10 als Parameter erhalten, um die Größe des Arrays zu kennen), aber ich muss die Größe nicht an die übergeben freie Funktion. Warum nicht, und kann ich dieselbe Technik in meinen eigenen Funktionen verwenden, damit ich nicht die zusätzliche Variable der Länge des Arrays herumschleppen muss?

Wenn du anrufst malloc(), geben Sie die zuzuweisende Speichermenge an. Die tatsächlich verwendete Speichermenge ist etwas größer und enthält zusätzliche Informationen, die (mindestens) aufzeichnen, wie groß der Block ist. Auf diese anderen Informationen können Sie nicht (zuverlässig) zugreifen – und das sollten Sie auch nicht :-).

Wenn du anrufst free()sieht es sich einfach die zusätzlichen Informationen an, um herauszufinden, wie groß der Block ist.

Die meisten Implementierungen von C-Speicherzuweisungsfunktionen speichern Abrechnungsinformationen für jeden Block, entweder inline oder separat.

Ein typischer Weg (inline) besteht darin, tatsächlich sowohl einen Header als auch den angeforderten Speicher zuzuweisen, der auf eine Mindestgröße aufgefüllt wird. Wenn Sie beispielsweise nach 20 Bytes gefragt haben, weist das System möglicherweise einen 48-Byte-Block zu:

• 16-Byte-Header, der Größe, spezielle Markierung, Prüfsumme, Zeiger auf den nächsten/vorherigen Block und so weiter enthält.
• 32 Bytes Datenbereich (Ihre 20 Bytes aufgefüllt auf ein Vielfaches von 16).

Die Ihnen dann mitgeteilte Adresse ist die Adresse des Datenbereichs. Wenn Sie dann den Block freigeben, free nimmt einfach die Adresse, die Sie ihm geben, und prüft, vorausgesetzt, Sie haben diese Adresse oder den Speicher um sie herum nicht vollgestopft, die Abrechnungsinformationen unmittelbar davor. Grafisch würde das in etwa so aussehen:

 ____ The allocated block ____
/                             \
+--------+--------------------+
| Header | Your data area ... |
+--------+--------------------+
          ^
          |
          +-- The address you are given

Denken Sie daran, dass die Größe des Headers und des Padding vollständig implementierungsdefiniert sind (eigentlich ist das Ganze implementierungsdefiniert ^(a) aber die Inline-Abrechnungsoption ist üblich).

Die in den Accounting-Informationen vorhandenen Prüfsummen und Sonderzeichen sind häufig die Ursache für Fehler wie „Memory Arena beschädigt“ oder „Doppelt frei“, wenn man sie überschreibt oder doppelt freigibt.

Das Auffüllen (um die Zuordnung effizienter zu gestalten) ist der Grund, warum Sie manchmal etwas über das Ende des angeforderten Bereichs hinaus schreiben können, ohne Probleme zu verursachen (tun Sie das trotzdem nicht, es ist ein undefiniertes Verhalten und, nur weil es manchmal funktioniert, nicht t meine, es ist in Ordnung, es zu tun).

^(a) Ich habe Implementierungen von geschrieben malloc in eingebetteten Systemen, in denen Sie 128 Bytes erhalten haben, egal was Sie angefordert haben (das war die Größe der größten Struktur im System), vorausgesetzt, Sie haben 128 Bytes oder weniger angefordert (Anforderungen nach mehr würden mit einem NULL-Rückgabewert beantwortet). Eine sehr einfache Bitmaske (dh nicht in Reihe) wurde verwendet, um zu entscheiden, ob ein 128-Byte-Chunk zugewiesen wurde oder nicht.

Andere, die ich entwickelt habe, hatten unterschiedliche Pools für 16-Byte-Blöcke, 64-Byte-Blöcke, 256-Byte-Blöcke und 1K-Blöcke, wobei wiederum eine Bitmaske verwendet wurde, um zu entscheiden, welche Blöcke verwendet oder verfügbar waren.

Beide Optionen haben es geschafft, den Overhead der Abrechnungsinformationen zu reduzieren und die Geschwindigkeit zu erhöhen malloc und free (keine Notwendigkeit, benachbarte Blöcke beim Freigeben zusammenzuführen), besonders wichtig in der Umgebung, in der wir gearbeitet haben.

Von dem comp.lang.c FAQ-Liste: Woher weiß Free, wie viele Bytes freizugeben sind?

Die malloc/free-Implementierung merkt sich die Größe jedes Blocks, wenn er zugewiesen wird, daher ist es nicht notwendig, ihn beim Freigeben an die Größe zu erinnern. (Normalerweise wird die Größe neben dem zugewiesenen Block gespeichert, weshalb die Dinge normalerweise schlecht brechen, wenn die Grenzen des zugewiesenen Blocks auch nur geringfügig überschritten werden.)

Diese Antwort wurde verschoben von Woher weiß free(), wie viel Speicher freigegeben werden muss? wo ich durch eine scheinbar doppelte Frage jäh daran gehindert wurde zu antworten. Diese Antwort sollte dann für dieses Duplikat relevant sein:

Für den Fall von mallocspeichert der Heap-Zuordner eine Abbildung des ursprünglich zurückgegebenen Zeigers auf relevante Details, die für benötigt werden freedie Erinnerung später. Dies umfasst typischerweise das Speichern der Größe des Speicherbereichs in irgendeiner Form, die für den verwendeten Zuordner relevant ist, beispielsweise die Rohgröße oder ein Knoten in einem binären Baum, der zum Verfolgen von Zuweisungen verwendet wird, oder eine Anzahl von verwendeten Speicher-“Einheiten”.

free wird nicht fehlschlagen, wenn Sie den Zeiger “umbenennen” oder ihn auf irgendeine Weise duplizieren. Es wird jedoch keine Referenz gezählt, sondern nur die erste free wird richtig sein. Zusätzlich frees sind “double free”-Fehler.

Versuchen free jeder Zeiger mit einem Wert, der sich von demjenigen unterscheidet, der von previous zurückgegeben wurde mallocs, und noch unfreigegeben ist ein Fehler. Es ist nicht möglich, Speicherbereiche, aus denen zurückgegeben wird, teilweise freizugeben malloc.

In einer verwandten Anmerkung GLib Die Bibliothek verfügt über Speicherzuweisungsfunktionen, die keine implizite Größe speichern – und dann übergeben Sie einfach den Größenparameter an free. Dadurch kann ein Teil des Overheads eliminiert werden.

Der Heap-Manager hat die Speichermenge, die zu dem zugewiesenen Block gehört, irgendwo gespeichert, als Sie ihn aufgerufen haben malloc.

Ich habe selbst nie einen implementiert, aber ich vermute, dass der Speicher direkt vor dem zugewiesenen Block die Metainformationen enthalten könnte.

malloc() und free() sind system-/compilerabhängig, daher ist es schwierig, eine spezifische Antwort zu geben.

Weitere Informationen zu dieser anderen Frage.