Wie bekomme ich die Speicherblocklänge nach malloc?

Question 1

Ich dachte, dass ich die Länge eines zugewiesenen Speicherblocks nicht so einfach abrufen könnte .length Funktion in Java. Allerdings weiß ich jetzt, wann malloc() den Block zuweist, weist es zusätzliche Bytes zu, um eine ganze Zahl zu halten, die die Größe des Blocks enthält. Diese Ganzzahl befindet sich am Anfang des Blocks; die Adresse, die tatsächlich an den Aufrufer zurückgegeben wird, zeigt auf die Stelle direkt hinter diesem Längenwert. Das Problem ist, dass ich nicht auf diese Adresse zugreifen kann, um die Blocklänge abzurufen.

#include <stdlib.h>
#include <stdio.h>
int main(void)
{
        char *str;
        str = (char*) malloc(sizeof(char)*1000);
        int *length;
        length = str-4; /*because on 32 bit system, an int is 4 bytes long*/
        printf("Length of str:%d\n", *length);
        free(str);
}

**Edit: Ich habe es endlich geschafft. Das Problem ist, dass es immer 0 gibt, da die Länge anstelle der Größe auf meinem System darauf zurückzuführen ist, dass mein Ubuntu 64-Bit ist. Ich habe str-4 in str-8 geändert, und es funktioniert jetzt.

Wenn ich die Größe auf 2000 ändere, wird 2017 als Länge ausgegeben. Wenn ich jedoch auf 3000 ändere, gibt es 3009. Ich verwende GCC.

Question 2

Sie müssen es nicht selbst verfolgen!

size_t malloc_usable_size (void *ptr);

Aber es gibt die tatsächliche Größe des zugewiesenen Speicherblocks zurück! Nicht die Größe, die Sie an malloc übergeben haben!

Question 3

Was du machst ist definitiv falsch. Obwohl es fast sicher ist, dass das Wort direkt vor dem zugewiesenen Block mit der Größe zusammenhängt, enthält es wahrscheinlich einige zusätzliche Flags oder Informationen in den nicht verwendeten Bits. Je nach Implementierung können sich diese Daten sogar in der befinden hoch Bits, was dazu führen würde, dass Sie die völlig falsche Länge lesen würden. Auch ist es möglich, dass kleine Allokationen (zB 1 bis 32 Byte) in spezielle Small-Block-Pages ohne Header gepackt werden, dann ist das Wort vor dem allokierten Block nur Teil eines anderen Blocks und hat in Bezug auf die Größe keinerlei Bedeutung des Blocks, den Sie untersuchen.

Stoppen Sie einfach diese fehlgeleitete und gefährliche Jagd. Wenn Sie die Größe eines erhaltenen Blocks wissen müssen mallocdu machst etwas falsch.

Question 4

Ich würde vorschlagen, dass Sie Ihren eigenen Malloc-Wrapper erstellen, indem Sie eine Datei kompilieren und verknüpfen, die my_malloc() definiert, und dann die Standardeinstellung wie folgt überschreiben:

// my_malloc.c

#define malloc(sz) my_malloc(sz)

typedef struct {
    size_t size;
} Metadata;

void *my_malloc(size_t sz) {
    size_t size_with_header = sz + sizeof(Metadata);
    void* pointer = malloc(size_with_header);

    // cast the header into a Metadata struct
    Metadata* header = (Metadata*)pointer;
    header->size = sz;    
    // return the address starting after the header 
    // since this is what the user needs
    return pointer + sizeof(Metadata);
}

dann können Sie immer die zugewiesene Größe abrufen, indem Sie sizeof(Metadata) subtrahieren, diesen Zeiger auf Metadata umwandeln und metadata->size ausführen:

Metadata* header = (Metadata*)(ptr - sizeof(Metadata));
printf("Size allocated is:%lu", header->size); // don't quote me on the %lu ;-)

Question 5

Das darfst du nicht. Wenn Sie wissen möchten, wie viel Speicher Sie zugewiesen haben, müssen Sie selbst den Überblick behalten.

Wenn Sie außerhalb des Ihnen zurückgegebenen Speicherblocks suchen (vor dem von malloc zurückgegebenen Zeiger oder nach diesem Zeiger + der Anzahl der angeforderten Bytes), führt dies zu einem undefinierten Verhalten. Es könnte in der Praxis für eine bestimmte Malloc-Implementierung funktionieren, aber es ist keine gute Idee, sich darauf zu verlassen.

Question 6

Dies ist nicht Standard C. Es soll jedoch auf Windows-Betriebssystemen funktionieren und möglicherweise auch auf anderen Betriebssystemen wie Linux (msize?) oder Mac (alloc_size?) verfügbar sein.

size_t _msize(void *memblock);

_msize() gibt die Größe eines im Heap allokierten Speicherblocks zurück.

Siehe diesen Link:
http://msdn.microsoft.com/en-us/library/z2s077bc.aspx

Question 7

Dies ist implementierungsabhängig

Question 8

Jedem Block, den Sie zuweisen, geht ein Blockdeskriptor voraus. Das Problem ist, es hängt von der Systemarchitektur ab. Versuchen Sie, die Blockdeskriptorgröße für Ihr eigenes System zu finden. Versuchen Sie, einen Blick auf Ihre System-Malloc-Manpage zu werfen.