Wenn free() die Länge meines Arrays kennt, warum kann ich sie dann nicht in meinem eigenen Code anfordern?

Ich weiß, dass es eine gängige Konvention ist, die Länge dynamisch zugewiesener Arrays an Funktionen zu übergeben, die sie manipulieren:

void initializeAndFree(int* anArray, size_t length);

int main(){
    size_t arrayLength = 0;
    scanf("%d", &arrayLength);
    int* myArray = (int*)malloc(sizeof(int)*arrayLength);

    initializeAndFree(myArray, arrayLength);
}

void initializeAndFree(int* anArray, size_t length){
    int i = 0;
    for (i = 0; i < length; i++) {
        anArray[i] = 0;
    }
    free(anArray);
}

aber wenn es für mich keine Möglichkeit gibt, die Länge des zugewiesenen Speichers von einem Zeiger zu erhalten, wie geht das? free() “automagisch” wissen, was ich freigeben soll, wenn ich nur denselben Zeiger gebe? Warum kann ich als C-Programmierer nicht in die Magie einsteigen?

Wo tut free() sein kostenloses (har-har) Wissen bekommen?

Abgesehen von Klatchkos korrektem Hinweis, dass der Standard dies nicht vorsieht, weisen echte malloc/free-Implementierungen oft mehr Platz zu, als Sie verlangen. Wenn Sie beispielsweise nach 12 Bytes fragen, können 16 bereitgestellt werden (siehe Ein Speicherzuordner, die anmerkt, dass 16 eine übliche Größe ist). Es muss also nicht wissen, dass Sie nach 12 Bytes gefragt haben, nur dass es gab dir ein 16-Byte-Stück.

Sie können es nicht bekommen, weil das C-Komitee das im Standard nicht verlangt hat.

Wenn Sie bereit sind, nicht portierbaren Code zu schreiben, haben Sie vielleicht Glück mit:

*((size_t *)ptr - 1)

oder vielleicht:

*((size_t *)ptr - 2)

Aber ob das funktioniert, hängt davon ab, wo genau die Implementierung von malloc, die Sie verwenden, diese Daten speichert.

Nachdem ich die Antwort von Klatchko gelesen hatte, versuchte ich es selbst und ptr[-1] tatsächlich speichert die tatsächlich Speicher (normalerweise mehr als der Speicher, um den wir gebeten haben, wahrscheinlich um gegen Segmentierungsfehler zu sparen).

{
  char *a = malloc(1);
  printf("%u\n", ((size_t *)a)[-1]);   //prints 17
  free(a);
  exit(0);
}

Beim Versuch mit verschiedenen Größen weist GCC den Speicher wie folgt zu:

Der anfänglich zugewiesene Speicher beträgt 17 Bytes.
Der zugewiesene Speicher ist mindestens 5 Bytes größer als die angeforderte Größe, wenn mehr angefordert wird, werden 8 Bytes mehr zugewiesen.

• Wenn Größe ist [0,12]zugewiesener Speicher ist 17.
• Wenn Größe ist [13]der zugewiesene Speicher beträgt 25.
• Wenn Größe ist [20]der zugewiesene Speicher beträgt 25.
• Wenn Größe ist [21]zugewiesener Speicher ist 33.

Obwohl es möglich ist, die Metadaten zu erhalten, die der Speicherzuordner vor dem zugewiesenen Block platziert, würde dies nur funktionieren wenn der Zeiger ist wirklich ein Zeiger auf einen dynamisch zugewiesenen Block. Dies würde die Nützlichkeit der Funktion ernsthaft beeinträchtigen, die erfordert, dass alle übergebenen Argumente Zeiger auf solche Blöcke sind, anstatt ein einfaches automatisches oder statisches Array zu sagen.

Der Punkt ist, dass es keinen tragbaren Weg von der Inspektion des Zeigers gibt, um zu wissen, auf welche Art von Speicher er zeigt. Obwohl es also eine interessante Idee ist, ist es keine besonders sichere Angelegenheit.

Eine sichere und tragbare Methode wäre, das erste Wort der Zuordnung zu reservieren, um die Länge zu halten. GCC (und vielleicht einige andere Compiler) unterstützt eine nicht-portable Methode, dies zu implementieren, indem eine Struktur mit einem Array der Länge Null verwendet wird, was den Code im Vergleich zu einer portablen Lösung etwas vereinfacht:

typedef struct
{
    size_t length ;
    char alloc[0] ;   // Compiler specific extension!!!
} tSizedAlloc ;

// Allocating a sized block
tSizedAlloc* blk = malloc( sizeof(tSizedAlloc) + length ) ;
blk->length = length ;

// Accessing the size and data information of the block
size_t blk_length = blk->length ;
char*  data = blk->alloc ;

Ich weiß, dieser Thread ist schon etwas älter, aber ich habe trotzdem etwas zu sagen. Es gibt eine Funktion (oder ein Makro, ich habe die Bibliothek noch nicht überprüft) malloc_usable_size() – erhält die Größe des vom Heap zugewiesenen Speicherblocks. Die Manpage gibt an, dass es nur zum Debuggen dient, da es nicht die Nummer ausgibt, die Sie gefragt haben, sondern die Nummer, die es zugewiesen hat, die etwas größer ist. Beachten Sie, dass es sich um eine GNU-Erweiterung handelt.

Andererseits wird es vielleicht nicht einmal benötigt, weil ich glaube, dass man seine Größe nicht kennen muss, um einen Speicherblock freizugeben. Entfernen Sie einfach das Handle/den Deskriptor/die Struktur, die für den Chunk verantwortlich ist.

Eine nicht standardmäßige Methode ist die Verwendung _msize(). Durch die Verwendung dieser Funktion wird Ihr Code nicht portierbar. Auch die Dokumentation ist nicht sehr klar, ob sie die übergebene Nummer zurückgibt malloc() oder die tatsächliche Blockgröße (möglicherweise größer).

Es liegt an der malloc Implementierer, wie diese Daten gespeichert werden. Meistens wird die Länge direkt vor dem zugewiesenen Speicher gespeichert (d. h. wenn Sie 7 Bytes zuweisen möchten, werden in Wirklichkeit 7+x Bytes zugewiesen, wobei die x zusätzlichen Bytes zum Speichern der Metadaten verwendet werden). Manchmal werden die Metadaten sowohl vor als auch nach dem zugewiesenen Speicher gespeichert, um auf Heap-Beschädigungen zu prüfen. Der Implementierer kann sich jedoch auch dafür entscheiden, eine zusätzliche Datenstruktur zum Speichern der Metadaten zu verwenden.