tableau dynamique des structures en C

Je suis en train d'apprendre sur les structures, pointeurs et tableaux dynamiques en C. je ne comprends pas comment créer un tableau dynamique de structures à l'aide de pointeurs. Mon code ne fonctionne pas, et je ne sais pas quel est le problème avec elle. J'ai vu plusieurs exemples de tableaux dynamiques, mais non avec des structures. Toute aide serait appréciée. Veuillez donner une explication, pas seulement des extraits de code que je veux comprendre, non seulement de résoudre ce problème.

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
struct *struct_array;
int i,m,n,p;
struct data
{
char inputA[20];
char inputB[20];    
};
struct data get_data()
{
struct data thisdata;
printf("Please enter input A\n");
scanf("%s", thisdata.inputA);
printf("Please enter input B\n");
scanf("%s", thisdata.inputB);
return thisdata;
}
void Output(struct data struct_array, int n)
{
int index = 0;
for(i = 0; i<n ;i++)
{
printf("%s ", struct_array[i].inputA);
printf("%s ", struct_array[i].inputB);
}   
}
void resizeArray(int n)
{
struct_array = (int*)realloc(n*sizeof(int));
}
void mainMenu()
{
printf("Please select from the following options:\n");
printf("1: Add new students to database\n");
printf("2: Display current student database contents\n");
printf("3: exit the program\n");
scanf("%d", &p);
if(p == 1)
{
printf("Please enter the number of students to register:\n");
scanf("%d", &n);
resizeArray(n);
for(i = n; i<n ;i++)
{
struct_array[i] = get_data();
}
}
else if(p == 2)
{
Output(struct_array, n);
}
else
{
free(struct_array);
exit(0);
}        
}
int main()
{    
struct_array = (int*)realloc(2*sizeof(int));
mainMenu();
}

structure de données *thisdata;
struct data *my_data = (struct data *)malloc(sizeof(struct data) * N); Où N est le nombre d'éléments que vous voulez dans votre tableau, il alloue de la mémoire pour les N éléments de type struct data
Les variables globales sont mauvais. Votre realloc-les appels sont incorrectes, le mieux est struct_array=realloc(struct_array,n*sizeof*struct_array)

OriginalL'auteur cHam | 2012-10-20

arrays c dynamic struct

5

Vous avez plusieurs erreurs dans votre code source:
- struct *struct_array; (l. 5)
  
  Ça veut dire quoi? Avez-vous eu envie d'écrire struct data *struct_array?
- printf("%s ", struct_array[i].inputA); (l.32 & l. 33)
  
  L'argument struct_array masques de la déclaration mondiale, et il n'est pas un tableau. Pourquoi avez-vous ajouter cet argument?
- struct_array = (int *)realloc(n * sizeof(int)); (l. 39)
  
  Vous avez oublié un argument. Voulez-vous utiliser malloc à la place? D'ailleurs, le casting n'est pas nécessaire (et incorrect!).
- Sauf si vous utilisez un hébergé environnment et C99/C11, vous devez renvoyer une valeur de main.
- Votre variable index n'est pas utilisé. Pourquoi avez-vous déclarer?
- for(i = n; i < n; i++) (l. 53)
  Vous n'aurez pas d'itération ici...
Le code suivant fonctionne comme prévu.
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* TODO: Avoid global variables. */
struct data *struct_array;
struct data {
char inputA[20];
char inputB[20];
};
/* 
* TODO: Try to avoid passing your structure (40 bytes + padding) 
* without pointer. 
*/
struct data get_data(void)
{
struct data thisdata;
printf("Please enter input A\n");
/* TODO: Avoid using `scanf` for human inputs. */
scanf("%s", thisdata.inputA);
printf("Please enter input B\n");
scanf("%s", thisdata.inputB);
return thisdata;
}
void Output(size_t n)
{
size_t i;
for (i = 0; i < n; i++) {
printf("%s ", struct_array[i].inputA);
printf("%s ", struct_array[i].inputB);
}
}
void resizeArray(size_t n)
{
/* TODO: Handle reallocations errors. */
struct_array = realloc(struct_array, n * sizeof *struct_array);
}
void mainMenu(void)
{
size_t i, n;
int p;
/* TODO: Use a loop ? */
printf("Please select from the following options:\n");
printf("1: Add new students to database\n");
printf("2: Display current student database contents\n");
printf("3: exit the program\n");
scanf("%d", &p);
switch (p) {
case 1:
printf("Please enter the number of students to register:\n");
scanf("%u", &n);
resizeArray(n);
for (i = 0; i < n; i++)
struct_array[i] = get_data();
break;
case 2:
Output(n);
break;
}
}
int main(void)
{
struct_array = malloc(2 * sizeof(int));
mainMenu();
free(struct_array);
return 0;
}
```
Je ne comprends pas vraiment comment allouer de la mémoire pour un pointeur est utilisé comme/pour un tableau. J'ai essayé de créer un tableau et à l'aide du pointeur de la longueur (tableau[pointeur]), mais n'a pas fonctionné. Je n'ai vraiment pas l'obtenir et j'ai lu plusieurs exemples qui n'ont tout simplement'e semblent m'aider à saisir le concept.
Je donne un exemple dans mon montage.
Vous ne pouvez faire qu'une opération, j'ai le mainMenu(); il a vraiment besoin d'une boucle quelque part autour de son appel ou dans son corps.
Merci beaucoup! Maintenant, je peux les comparer pour voir où je suis allé mal, qui est extrêmement utile. Merci pour les suggestions supplémentaires ainsi!

OriginalL'auteur md5
4

Votre définition
```
struct *struct_array;
```
est erronée. Vous devez utiliser le nom de votre type, la data.
```
struct data *struct_array;
```
De cette façon, vous pouvez allouer le tableau
```
struct_array = malloc(MaxNumElements * sizeof(struct data));
```
et, plus tard, vous devez libérer la mémoire
```
free(struct_array);
```
EDIT: définition de Type doit avoir lieu avant la var déclaration.
```
struct data ....
struct data* your_variable;
```
P. S. Si vous ne voulez pas taper struct mot-clé chaque fois que vous utilisez le data type, utilisez la typedef:
```
typedef struct data_s
{
char inputA[20];
char inputB[20];    
} data;
```
Je reçois un message d'erreur qui struct_array est non déclaré. Quel est le problème ?
Vous devez utiliser le data après avoir été déclarée, et non pas avant comme vous le faites. Désolé de ne pas le rappeler. Ajoutée à ma réponse

OriginalL'auteur Viktor Latypov
2

Savez-vous comment utiliser typedef?

Je dirais, rend votre code plus facile à comprendre et que vous n'aurez pas à avoir à taper le mot struct un millier de fois. Vous pouvez également traiter le nouveau type similaire pour les types primitifs (entiers, caractères, etc), il suffit de ne pas oublier d'utiliser le point (.) pour accéder aux champs de l'individu que vous pourriez vouloir.

Vous pouvez taper par exemple:
```
    typedef struct{
char inputA[20];
char inputB[20];
} data;
```
Maintenant, vous pouvez déclarer des variables comme ceci:
```
   data data_variable;
data *pointer_to_data;
```
Et de vous pourrait allouer de la mémoire comme suit:
```
   pointer_to_data = (data*) malloc(sizeof(data)* N);
```
où N est la quantité de structure de données que vous souhaitez allouer. Même travaille pour le realloc.

OriginalL'auteur vmp
0

struct_array = (int*)realloc(2*sizeof(int));

Par la déclaration ci-dessus vous essayez d'affecter l'adresse d'un entier à un pointeur de type struct data.

Vous devez utiliser:
```
struct_array = (struct data*)realloc(2*sizeof(struct data));
```
OriginalL'auteur akaHuman

Vous devez vous connecter pour publier un commentaire.