Ich fand heraus, wie realloc zu schreiben, aber ich weiß, dass der Code nicht richtig ist?

Question

Was ich beschlossen, zu tun

• Aufruf malloc
• Kopieren Sie den alten Block auf den neuen Block
• den alten Block
• und gibt den Zeiger auf den neuen Block

Sie den Code unten ist, was ich bisher ... aber ich weiß, dass es nicht richtig ist ... jede Hilfe Sie den Code auf Festsetzung wäre sehr dankbar ...

Wenn Sie mehr Code benötigen als das, was ich zur Verfügung gestellt habe, habe ich einen Beitrag vor dieser eine, die den gesamten Code zeigt. Ich bin neu, so dass es nur dieser Beitrag und der letzte Beitrag ist ich getan habe. Danke.

void *mm_realloc(void *ptr, size_t size)
{
int i, p = *ptr;

 // make a call to malloc to find space
 //allocate memory

 ptr = malloc(size_t*sizeof(int));

 //copying old block to new block
 if(ptr!=NULL)
     for(i=0 ; i<size_t ; i++) 
     {
     *(ptr+i) = i;
     }

//freeing old block
free(ptr);

//return pointer to new block
return *ptr;
}

Answer 1

Idealerweise würde ein realloc() einfach sehen, ob es jenseits des aktuellen Blocks genügend freier Speicherplatz ist, und wenn ja, nur die Strukturen Arena Daten stellen Sie den aktuellen Block an Ort und Stelle zu erweitern. Dies wird von dem teueren Kopiervorgang zu befreien und reduziert die Chancen von Zuordnungsfehlern. Das ist für die Größe zu erhöhen. Zur Reduzierung, sollten Sie in der Lage sein, es immer an Ort und Stelle zu tun ist, um den Rest des aktuellen Blockes zurück zum freien Pool zu senden.

, indem Sie eine malloc / free, wenn Sie 100K in der Arena mit einem einzigen 60K Block zugeordnet haben, rufen Sie Ihre mm_realloc die Größe 50K anpassen wird fehlschlagen.

Es ist jedoch ein bearbeitbar Lösung, zumindest für einen ersten Versuch, so ist hier, wie ich es umsetzen würde:

void *mm_realloc (void *ptr, size_t size) {
    int minsize;
    void *newptr;

    // Allocate new block, returning NULL if not possible.

    newptr = malloc (size);
    if (newptr == NULL) return NULL;

    // Don't copy/free original block if it was NULL.

    if (ptr != NULL) {
        // Get size to copy - mm_getsize must give you the size of the current block.
        // But, if new size is smaller, only copy that much. Many implementations
        // actually reserve the 16 bytes in front of the memory to store this info, e.g.,
        // +--------+--------------------------------+
        // | Header | Your data                      |
        // +--------+--------------------------------+
        //           ^
        //           +--- this is your pointer.
        // <- This is the memory actually allocated ->

        minsize = mm_getsize (ptr);
        if (size < minsize)
           minsize = size;

        // Copy the memory, free the old block and return the new block.

        memcpy (newptr, ptr, minsize);
        free (ptr)
    }

    return newptr;
}

Eine Sache, werden Sie feststellen, das ist von Ihnen fehlt, ist, dass es nur genug Bytes für die kleinste kopieren hat der alten und neuen Blöcke. Andernfalls riskieren Sie Core-Dumps von einem von ihnen überfüllt.

Darüber hinaus hat die Schleife nicht wirklich die Daten kopieren, setzen sie jedes Byte des Blockes zu seinem versetzt, und sie verlor die alten Zeiger, wenn die neue Zuteilung, daher meine Verwendung von newptr, um sich zu trennen.

Answer 2

Sie müssen wissen, wie groß der alte Block sowie die neue Größe ist. Sie haben die kleinere der beiden Größen über den neuen Block zu kopieren.

Sie müssen auch sicherstellen, dass Sie nicht zerstören (kostenlos), um den alten Block, wenn die malloc () nicht - man muss nur 0 zurück

.

Sie brauchen auch nicht die Größe von 'sizeof (int)' in der malloc () zu multiplizieren; Sie sind wirklich um einen Faktor von 4 oder mehr overallocating (in der Theorie, könnte es nur ein Faktor von 2, aber nur wenige Menschen benutzen, 16-Bit-Compiler in diesen Tagen).

Answer 3

Der Punkt der realloc ist, dass sie versucht, den Speicherblock, der mit einem freien hinter dass, wenn möglich zu fusionieren. Nur wenn es keine frei ist, wird es neue Speicher zuweisen, kopieren Sie alles über und gibt den alten Block.

Warum werden Sie Ihre eigenen Zuweisungsroutinen schreiben sowieso?