Allocation tableau dynamique ds structureRésolu

Question

Salut à tous,

Sauriez vous me dire comment allouer dynamiquement un tableau dans une structure ?

J'arrive à faire l'essentiel mais dans la structure je n'y arrive pas, voici un exemple de code qui illustre le probleme :

typedef struct /* Déclaration de notre structure */
{
char nom[30];
char code;
int cotes[];
}Element;
Element *Pelm;

Pelm=malloc(4 * sizeof(int));

> jusque là ça va, mais quand je fais :

Pelm[i].cotes=malloc(3 * sizeof(int)); 
Là j'ai une erreur de type C2106.

turnerom · Accepted Answer

Moi, je ferais plutot :






typedef struct /* Déclaration de notre structure */

{

  char nom[30];

  char code;

  int *cotes;

}Element;


Element *Pelm=(Element*)malloc(sizeof(Element));

Pelm[i].cotes=(int*)malloc(3 * sizeof(int));




TuRn3r

Galmiza · Answer

Il te faut un pointeur à la place d'un tableau.

typedef struct /* Déclaration de notre structure */
{
char nom[30];
char code;
int *cotes;
}Element;
Element *Pelm;

Pelm[i].cotes=malloc(3 * sizeof(int)); 

@+

DeAtHCrAsH · Answer

Je suis pas vraiment d'accord sur certaines chose. 
Voila un code juste a mon sens :

typedef struct 
{
int * cotes;
char nom[32];   // Toujours des multiple de 8 pour l'allignement des données!!!!
char code;
}ELEMENT;

ELEMENT *pElm;

pElm = malloc(4 * sizeof(ELEMENT )); // Pourquoi avoir mis la taille d'un int ????

pElm[i].cotes = malloc(3 * sizeof(int));  

Shell

turnerom · Answer

Exact, je suis d'accord avec toi DeAtHCrAsH pour le malloc, on a posté + ou - en meme temps !

TuRn3r

DeAtHCrAsH · Answer

Fait attention turnerom, il y a une incohérence dans ton code :

Element *Pelm= (Element*)malloc(sizeof(Element));
Pelm[i].cotes=(int*)malloc(3 * sizeof(int));  

Tu mets Pelm[i] alors que tu initialises ta structure avec un seul element : Element *Pelm  = (Element*)malloc(sizeof(Element)); <= === Un seul element est intialiser ici!

Dans ton cas, deux solutions :

¤ Tu as besoin de une seule structure :
Element *Pelm=(Element*)malloc(sizeof(Element));
Pelm->cotes=(int*)malloc(3 * sizeof(int));  

¤ Tu as besoin de N structure (ex : N  = 10) :
Element *Pelm=(Element*)malloc(10 * sizeof(Element));
Pelm[i]cotes=(int*)malloc(3 * sizeof(int));

Dans cette derniere solution on a donc un tableau de structure.

Shell

steve_clamage · Answer

typedef struct /* Déclaration de notre structure */

{

char nom[30];

char code;

int cotes[];

}Element;


Avant de dir que c'est faux il faut connaitre. C'est tout à fait valide
en C99, et c'est fort pratique. Il s'agit d'une structure imcomplete,
la taille du tableau (qui n'en n'est pas un) sera fixée dynamiquement
suivant la taille de la zone allouée. L'avantage c'est que le "tableau"
se trouve à la suite des autres attributs de la structure et n'est pas
dispersé comme on ferait en stockant son adresse avec un pointeur.
L'autre avantage c'est que tout se fait en une allocation.


size_t n = 5; /* taille voulue pour le tableau cotes */

Element * p = malloc(sizeof *p + n * sizeof p->cotes);

DeAtHCrAsH · Answer

Petite précision suite à la remarque de steve_clamage.
Tout tableau n'est en fait qu'un pointeur et ceci pour n'importe quel type, d'ou sa remarque.
Au passage steve, personne n'a dis que c'etait faux, on ne fait que proposer des solutions...

Shell

steve_clamage · Answer

En fait j'avas fait cette remarque parce que justement un tableau n'est
pas un pointeur, d'ailleur je me suis trompé, cotes est bien un tableau.

La différence entre un tableau et un pointeur c'est que un tableau est
une adresse alors q'un pointeur est une variable qui contient une
adresse.

int * p = malloc(n * sizeof *p);

p contient l'adresse d'un bloc memoire de n int contigues qu'on manipulera comme un tableau d'entier mais ca n'en est pas un.


De plus la taille est connue a la compilation, et comme pour toute
variable sizeof renvoi la taille du tableau (alors que sur un pointeur
ca renvoi la taille du pointeur forcement). En C99 avec les vla, sizeof
est resolu dynamiquement pour le coup. Dans le cas des structures
incompletes de ce type, le sizeof est résolu statiquement mais renvoi
la taille de la structure sans la taille du dernier tableau dont la
taille n'est pas spécifiée.


La correction de ce que j'avais écris

 size_t n = 5; /* taille voulue pour le tableau cotes */

 Element * p = malloc(sizeof *p + n * sizeof(int));

Galmiza · Answer

Que se passe-t-il si tu fais:

typedef struct /* Déclaration de notre structure */
{
 int cotes[];
char nom[30];
char code;
}Element;

Element* pElmt = (Element*)malloc(100);

Les 69 octets non attribués sont-ils accessibles en un seul segment via le pointeur pElmt->cotes ?

Ou faut-il obligatoirement mettre le tableau cotes[] en fin de définition ?
Enfin, qu'advient-il si il y a deux tableaux cotes1[] et cotes2[] dans la structure, ah ah ?!

steve_clamage · Answer

Bonnes questions, il ne peut y en avoir que un et il doit se trouver à la fin.

cs_Emmanuel Delahaye · Answer

Pour éviter de se poser trop de questions sur les type, je conseille d'écrire du code 'auto-démerdant': 
ELEMENT *pElm =  malloc (4 * sizeof *pElm);
pElm[i].cotes =  malloc(3 * sizeof * pElm[i].cotes);  

et ne pas oublier de tester le valeurs retournées par malloc()..

<hr size ="2" width="100%" />C is a sharp tool ! 
[mapage.noos.fr/emdel Des infos sur le C
]

Allocation tableau dynamique ds structure

11 réponses

Votre réponse

Discussions similaires