realloc bug - incrémenter le dernier élément du tableau

Question

J'essaye d'implémenter un tableau dinamically croissant avec realloc. Je crée le tableau avec malloc, puis appeler ma fonction add, ce qui augmente la taille du tableau par 1. Voici le code:

#include <stdio.h> 
#include <stdlib.h> 

int *foo; 
int quantity; 

void add(int number) { 
    foo = (int*) realloc(foo, sizeof(foo) + sizeof(int)); 
    foo[quantity] = number; 
    quantity++; 
} 

void debugFoo() { 
    for (int i = 0; i < quantity; i++) { 
     printf("foo[%i] = %i\n", i, foo[i]); 
    } 
    printf("\n"); 
} 

int main() { 
    quantity = 3; 
    foo = (int*) malloc(quantity * sizeof(int)); 

    foo[0] = 1; 
    foo[1] = 2; 
    foo[2] = 3; 

    debugFoo(); 

    add(20); 
    debugFoo(); 
    add(2); 
    debugFoo(); 

    return 0; 
} 

Cependant quand je le lance, je reçois la sortie suivante:

foo[0] = 1 
foo[1] = 2 
foo[2] = 3 

foo[0] = 1 
foo[1] = 2 
foo[2] = 3 
foo[3] = 20 

foo[0] = 1 
foo[1] = 2 
foo[2] = 3 
foo[3] = 21 
foo[4] = 2 

Comme vous pouvez le voir, la valeur de foo [3] est incrémentée de 1 la seconde fois que j'appelle add. Et la chose étrange est qu'il est seulement incrémenté si la première valeur passée à add est paire. Changement de ligne 30-add(21), je reçois la sortie suivante:

[...] 
foo[2] = 3 
foo[3] = 21 

foo[0] = 1 
foo[1] = 2 
foo[2] = 3 
foo[3] = 21 
foo[4] = 2 

Est-ce un bug ou que j'utilise realloc mal?

Answer 1

sizeof(foo) est pas la taille de tampon alloué, mais la taille de foo, qui est int*. Utilisez le nombre d'éléments enregistrés pour calculer la nouvelle taille du tampon.

foo = (int*) realloc(foo, sizeof(int) * (quantity + 1)); 

Answer 2

sizeof(foo) est Retournez-vous toujours la même valeur, probablement 4. En raison de l'opérateur sizeof est vous retourne la taille de int *

Vous avez « correctement » a déclaré une variable de portée globale (quantity) qui stockent la taille actuelle de votre tableau, utilisez cette variable à realloc votre structure, comme vous l'avez fait avec malloc.

void add(int number) { 
    quantity++; 
    foo = realloc(foo, (quantity * sizeof(int))); 
    if (foo != NULL) 
    { 
     foo[quantity-1] = number; 
    } 
    else 
    { 
     fprintf(stderr, "Failed to add number.\n"); 
    } 
} 

Notez qu'il est très important de toujours vérifier les valeurs de retour des fonctions. Comme indiqué dans mon exemple pour la valeur retournée de realloc vous devez faire la même chose pour malloc dans main fonction.

int main() { 
    quantity = 3; 
    foo = malloc(quantity * sizeof(int)); 
    if (foo != NULL) 
    { 
     foo[0] = 1; 
     foo[1] = 2; 
     foo[2] = 3; 

     debugFoo(); 

     add(20); 
     debugFoo(); 
     add(2); 
     debugFoo(); 

     return 0; 
    } 
    else 
    { 
     fprintf(stderr, "Failed to allocate array.\n"); 
     return 1; 
    } 
}