Realloc un tableau de Structures

Je suis en train de réallouer dynamiquement de la mémoire pour un tableau de struct (en fait une matrice de chacune des 2 structures, mais 1 inclus ici pour plus de simplicité) qui est lu à partir de/vers un fichier ou saisie par l'utilisateur.

typedef Struct
{
    char surname[21];
    char firstname[21];
    char username[21];
...
} User;

...dans main():

int size = 0; /* stores no. of structs */
User* user_array = (User *) calloc(1, sizeof(User));
if(user_array == NULL)
{
    printf("Cannot allocate initial memory for data\n");
    exit(1);
}
else
    size++;

Je suis d'essayer d'utiliser un appel de fonction pour augmenter le tableau en cas de besoin:

int growArray(User user_array*, int size)
{
    User *temp;
    size++;
    temp = (User *) realloc(user_array, (size * sizeof(User));
    if(temp == NULL)
    {
        printf("Cannot allocate more memory.\n");
        exit(1);
    }
    else
        user_array = temp;
    return size;
}

Malheureusement, le realloc ne fonctionne jamais. Les deux structures sont que d'environ 200 octets par exemple et le réglage de la taille initiale-à-dire 10 fonctionnera très bien, donc il doit y avoir quelque chose de mal avec la façon dont je suis en train d'utiliser realloc.

Système Win 7 64, sur Core i5 avec 4 go, l'exécution de Quincy (un MinGW GUI).

int growArray(User user_array, int size)? Vous manque un *?
post le vrai code ne compile pas
Je pense qu'il manque deux d'entre eux.
Si vous obtenez cela fonctionne, vous pouvez simplifier le code en faisons aussi de la répartition initiale avec growArray. Aussi, soyez conscient que votre calloc() permet d'initialiser la première entrée, tandis que la postérieure realloc() va quitter la zone d'extension non initialisée. Comme cnicutar notes, la "taille++" ne sera pas visible à l'appelant.
dantje - pour le moment je suis en utilisant la taille de ma valeur de retour - désolé pour le laisser sortir
cette chose que vous appelez la taille doit être appelée longueur
ce serait plus précis que je suis de ne pas stocker. d'éléments dans le tableau. Dans mon programme (trop long d'énumérer ici), il est no_elements

InformationsquelleAutor thelionroars1337 | 2011-05-29

arrays c realloc struct

3

Vous êtes à la modification de la valeur de user_array localement. La valeur est perdue lorsque la fonction retourne. Passer un pointeur vers la user_array pointeur à la place.
- Et un pointeur de taille trop...
- Désolé j'ai oublier d'ajouter l' * mon code ci-dessus... c'est corrigé maintenant.
- Merci - c'était le problème. Je ne comprenais pas jusqu'à ce que d'autres affiches ont été plus précis sur la façon de le faire.
InformationsquelleAutor Richard Pennington
6

realloc modifie la taille de la mémoire pointée par user_array à la taille spécifiée, il n'a pas l'augmenter en taille. Voyant que votre fonction est appelée growArray, j'avais suppose que vous le souhaitez augmenter la taille de la matrice par size, dans ce cas, vous devez:
```
int growArray(User **user_array, int currentSize, int numNewElems)
{
    const int totalSize = currentSize + numNewElems;
    User *temp = (User*)realloc(*user_array, (totalSize * sizeof(User)));

    if (temp == NULL)
    {
        printf("Cannot allocate more memory.\n");
        return 0;
    }
    else
    {
        *user_array = temp;
    }

    return totalSize;
}
```
Noter que growArray prend l'adresse de user_array, la raison pour cela est que realloc peut-être déplacer la mémoire si elle ne pouvait pas étendre l'interdiction à la taille requise.

Pour l'utiliser:
```
int size = 0;
User* user_array = (User *) calloc(1, sizeof(User));
if(user_array == NULL)
{
    printf("Cannot allocate initial memory for data\n");
    exit(1);
}

/* add 10 new elements to the array */
size = growArray(&user_array, size, 10);
```
- La taille est égale au nombre de structures dans le tableau (avant augmentation) lorsqu'elle est passée à growArray. La taille++ dans growArray va augmenter ce pour le nouveau numéro (destiné à être augmenté de 1 à un moment - d'un inconnu pas. des entrées dans le fichier ou par l'utilisateur de l'ajout) donc je crois que la taille * sizeof(Utilisateur) est correct pour cette approche. J'ai remarqué que vous avez utilisé la double indirection opérateur @cnicutar a, je suis encore à essayer d'obtenir ma tête autour de ce qui s'y passe. Ce doit être l'endroit où je vais mal... si je ne fais pas de cette façon, je vais toujours utiliser l'ancienne adresse de début de user_array?
- Oui, ça pourrait être votre problème. realloc pourrait ne pas être en mesure d'étendre votre user_array pointeurs bloc de mémoire à être assez grand pour la nouvelle taille. Si cela se produit, il alloue un nouveau bloc de mémoire quelque part d'autre, et des copies de tout, de la user_array plus. La valeur de retour est le nouvel emplacement de la mémoire. En utilisant le pointeur vers un pointeur permet growArray pour mettre à jour la valeur de user_array de l'appelant, que sa valeur précédente est maintenant invalide.
InformationsquelleAutor Node

Vous devez vous connecter pour publier un commentaire.