realloc

Weist den angegebenen Speicherbereich neu zu. Wenn ptr nicht NULL ist, muss es zuvor durch malloc , calloc oder realloc allokiert und noch nicht durch einen Aufruf von free oder realloc freigegeben worden sein. Andernfalls ist das Verhalten undefiniert.

Die Neuzuordnung erfolgt entweder durch:

Wenn nicht genügend Speicher vorhanden ist, wird der alte Speicherblock nicht freigegeben und ein null-Zeiger zurückgegeben.

Wenn ptr gleich NULL ist, ist das Verhalten dasselbe wie beim Aufruf von malloc ( new_size ) .

Andernfalls,

Parameter

Rückgabewert

Bei Erfolg gibt den Zeiger auf den Anfang des neu zugewiesenen Speichers zurück. Um einen Speicherverlust zu vermeiden, muss der zurückgegebene Zeiger mit free oder realloc freigegeben werden. Der ursprüngliche Zeiger ptr wird ungültig und jeglicher Zugriff darauf ist undefiniertes Verhalten (selbst wenn die Neuzuweisung in-place erfolgte).

Bei Fehler wird ein Nullzeiger zurückgegeben. Der ursprüngliche Zeiger ptr bleibt gültig und muss möglicherweise mit free oder realloc freigegeben werden.

Hinweise

Ursprünglich (in C89) wurde die Unterstützung für Null-Größe hinzugefügt, um Code wie folgenden zu ermöglichen:

OBJ *p = calloc(0, sizeof(OBJ)); // Platzhalter mit "Null-Länge"
/*...*/
while (1)
{
    p = realloc(p, c * sizeof(OBJ)); // Reallokationen bis Größe stabilisiert
    /* Code, der c ändern oder Schleife abbrechen könnte */
}

Beispiel

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void print_storage_info(const int* next, const int* prev, int ints)
{
    if (next)
        printf("%s location: %p. Size: %d ints (%ld bytes).\n",
               (next != prev ? "New" : "Old"), (void*)next, ints, ints * sizeof(int));
    else
        printf("Allocation failed.\n");
}
int main(void)
{
    const int pattern[] = {1, 2, 3, 4, 5, 6, 7, 8};
    const int pattern_size = sizeof pattern / sizeof(int);
    int *next = NULL, *prev = NULL;
    if ((next = (int*)malloc(pattern_size * sizeof *next))) // allocates an array
    {
        memcpy(next, pattern, sizeof pattern); // fills the array
        print_storage_info(next, prev, pattern_size);
    }
    else
        return EXIT_FAILURE;
    // Reallocate in cycle using the following values as a new storage size.
    const int realloc_size[] = {10, 12, 512, 32768, 65536, 32768};
    for (int i = 0; i != sizeof realloc_size / sizeof(int); ++i)
    {
        if ((next = (int*)realloc(prev = next, realloc_size[i] * sizeof(int))))
        {
            print_storage_info(next, prev, realloc_size[i]);
            assert(!memcmp(next, pattern, sizeof pattern));  // is pattern held
        }
        else // if realloc failed, the original pointer needs to be freed
        {
            free(prev);
            return EXIT_FAILURE;
        }
    }
    free(next); // finally, frees the storage
    return EXIT_SUCCESS;
}

New location: 0x144c010. Size: 8 ints (32 bytes).
Old location: 0x144c010. Size: 10 ints (40 bytes).
New location: 0x144c450. Size: 12 ints (48 bytes).
Old location: 0x144c450. Size: 512 ints (2048 bytes).
Old location: 0x144c450. Size: 32768 ints (131072 bytes).
New location: 0x7f490c5bd010. Size: 65536 ints (262144 bytes).
Old location: 0x7f490c5bd010. Size: 32768 ints (131072 bytes).

Referenzen

Siehe auch