Allocation tableau dynamique ds structure

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));

@+

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

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

TuRn3r

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

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);

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

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));

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 ?!