realloc

Reasigna el área de memoria dada. Si ptr no es NULL, debe haber sido previamente asignado por malloc , calloc o realloc y no haber sido liberado con una llamada a free o realloc . De lo contrario, los resultados son indefinidos.

La reasignación se realiza mediante una de las siguientes opciones:

Si no hay suficiente memoria, el bloque de memoria anterior no se libera y se devuelve un puntero nulo.

Si ptr es NULL , el comportamiento es el mismo que llamar a malloc ( new_size ) .

De lo contrario,

Parámetros

Valor de retorno

En caso de éxito, retorna el puntero al inicio de la memoria recién asignada. Para evitar una fuga de memoria, el puntero retornado debe ser desasignado con free o realloc . El puntero original ptr queda invalidado y cualquier acceso al mismo es comportamiento indefinido (incluso si la realocación fue en el mismo lugar).

En caso de fallo, retorna un puntero nulo. El puntero original ptr permanece válido y puede necesitar ser desasignado con free o realloc .

Notas

Originalmente (en C89), se añadió soporte para tamaño cero para adaptarse a código como

OBJ *p = calloc(0, sizeof(OBJ)); // marcador de posición de "longitud cero"
/*...*/
while (1)
{
    p = realloc(p, c * sizeof(OBJ)); // reasignaciones hasta que el tamaño se estabilice
    /* código que puede cambiar c o salir del bucle */
}

Ejemplo

#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).

Referencias

Véase también