realloc

Réalloue la zone de mémoire donnée. Si ptr n'est pas NULL, il doit avoir été préalablement alloué par malloc , calloc ou realloc et ne pas encore avoir été libéré par un appel à free ou realloc . Sinon, le comportement est indéfini.

La réallocation se fait soit par :

S'il n'y a pas assez de mémoire, le bloc de mémoire ancien n'est pas libéré et un pointeur nul est retourné.

Si ptr est NULL , le comportement est le même que celui de l'appel à malloc ( new_size ) .

Sinon,

Paramètres

Valeur de retour

En cas de succès, retourne le pointeur vers le début de la mémoire nouvellement allouée. Pour éviter une fuite mémoire, le pointeur retourné doit être désalloué avec free ou realloc . Le pointeur original ptr est invalidé et tout accès à celui-ci est un comportement indéfini (même si la réallocation a été effectuée en place).

En cas d'échec, retourne un pointeur nul. Le pointeur original ptr reste valide et pourrait nécessiter une désallocation avec free ou realloc .

Notes

À l'origine (en C89), la prise en charge de la taille zéro a été ajoutée pour accommoder du code tel que

OBJ *p = calloc(0, sizeof(OBJ)); // espace réservé de "longueur nulle"
/*...*/
while (1)
{
    p = realloc(p, c * sizeof(OBJ)); // réallocations jusqu'à stabilisation de la taille
    /* code susceptible de modifier c ou de sortir de la boucle */
}

Exemple

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

Références

Voir aussi