Pointeurs et structures...

Hello,
Voila mon problème:
Je souhaite modéliser un groupe de personne auquel on peu ajouter/enlever etc... dynamiquement des individus.
Pouir cela, j'ai crée deux structure:
- une pour les individus qui contiendra des attributs standarts...
- une pour le groupe, elle contient un pointeur de type individu qui servira de tableau dynamique pour les individus.

Je souhaite ensuite ajouter les methodes standards... tout ca est résumé dans mon code ci-dessous:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

#include <windows.h> #include <stdio.h>   typedef struct individu { char* nom; } individu ;   typedef struct groupe{ int nbPers ; individu *indivs ; // Pointeur = tableau d'individus } groupe ;   individu* creerIndividu () { individu *indiv ; indiv = calloc(1, sizeof(individu)) ; return indiv ; }   groupe* creerGroupe(int nbPers) { groupe* gp ; // Pointeur sur le nouveau groupe gp = malloc(sizeof(groupe)); // Allocation de mémoire pour le groupe (*gp ).indivs = malloc(nbPers* sizeof(individu)) ; // Allocation de mémoire pour les individus   int i ; for(i = 0 ; i < nbPers; i++) { gp->(indivs+i) = creerIndividu() ; //pb a la compilation }   return gp ; }   int main(void) { int nbIndiv= 5 ; groupe *gp ; gp = creerGroupe(nbIndiv) ; }

---

A la compilation, j'ai le droit a une syntax error au niveau de l'instruction:

Code:

---

gp->(indivs+i) = creerIndividu()

---

Quelqu'un voit il l'erreur? C'est surement au niveau des pointeurs, je ne maitrise pas encore bien... mais j'ai beau chercher je ne trouve pas de solutiosn.

Merci d'avance.

Code:

---

gp->(indivs+i) = creerIndividu() ; //pb a la compilation

---

C'est un peu normal du reste. Tu voulais peut-être dire *(gp->indivs + i) = creerIndividu()? Mais comme c'est un peu lourd on préfère utiliser gp->indivs[i] = creerIndividu().

ben non si je fais ca il me dit: "incompatible types assignment"...
Ma méthode creeIndividu() renvoi un pointeur, dc une adresse, donc je suppose que c'est pr ca... gp->indivs[i] c'est pas un pointeur

Il me semble que dans ce cas là, CreerIndividu ne doit pas renvoyer un pointeur mais bien un Individu.

Puisque gp->indiv[i] désigne un individu et non un pointeur sur un individu.

EDIT : Pas lu ce que tu as écrit avant. En effet tu possédes déja un tableau d'individu. Tu peux à la rigeur dans CreerIndividu allouer la mémoire pour le champs nom de ta structure Individu

En effet ca marche si on renvoi un individu.
Seulement dans le tableau je voudrai avoir des pointeurs sur des individus et non des individus (pour pouvoir les modifier ensuite)... C'est pourquoi ma fonction creerIndividu renvoi un pointeur.
En fait j'ai trouvé la solution, il faut que ma structure groupe soit comme ceci:

Code:

---

1 2 3 4

typedef struct groupe{ int nbPers ; individu **indivs ; // Pointeur = tableau de pointeurs sur les individis } groupe ;

---

Seulement maintenant je n'arrive pas à accéder aux individus a partir d'un groupe...

Code:

---

1 2 3 4 5 6 7 8 9 10

void afficherIndividu(individu indiv) {...}   void afficherGroupe(groupe gp) { int i ; for (i=0 ; i < gp.nbPers ; i++){ afficherIndividu(gp.(*(indivs[i])) ; // Syntax error } }

---

J'ai la même erreur que tout a l'heure: syntax error...

Il sort d'ou pop ? Bob ?

lol dsl erreur de frappe c'est modifié

Il te manque une parenthése fermante ')'

oui, mais ca ne marche pas quand même de cette manière... La syntaxe du C ne le permet pas apparament ou alors c'est moi.
En tout cas je vien juste de trouver la solution: il fait déclarer un pointeur pour récupérer les éléments du tableau (les pointeurs)...
Ca donne ca:

Code:

---

1 2 3 4 5

for (i=0 ; i < gp.nbPers ; i++){ individu *indiv = gp.indivs[i] ; // On récup le pointeur sur l'individu i afficherIndividu(*indiv) ; // On affiche l'individu }

---

EDIT : j'ai dis une connerie :oops:

Ma fonction afficherIndividu attend un individu, non un pointeur sur un individu, comme c'est décrit plus haut (juste au dessu de la fonction afficherGroupe).
Et selon ma structure groupe: (voir plus haut également, indivs est un tableau de pointeurs)

Code:

---

gp.indivs[i]

---

renvoi un pointeur sur l'individu i, et non l'individu i, ce qui veu dire que cette instruction:

Code:

---

1 2	afficherIndividu(gp.indivs[i]); // Ici on envoi un pointeur a la fonction

---

n'est pas équivalente à:

Code:

---

1 2 3

individu *indiv = gp.indivs[i] ; afficherIndividu(*indiv) ; // Ici on envoi bien un individu

---

Désolé si tout cela n'a peut etre pas été trés clair, mais je ne maitrise pas encore trés bien les pointeurs, et c'est pourquoi tu as du avoir l'impression que je voulai passer un pointeur, puis un individu a la fonction, alors que j'ai toujours voulu passe un individu :)

Il faut faire attention à ce que tu fais:

- Lorsque tu passes une structure à une fonction, il y a une copie superficielle de la structure (toutes les valeurs statiquement déclarées donc les valeurs des pointeurs mais pas les valeurs pointées)

Cela a deux conséquences:

- Lors de la modification de la structure, cela revient à modifier un paramétre de la fonction, la structure qui a été passée en argument n'a pas été modifiée.

- Il y a un coût pour passer des grosses structures dû au nombre de copie nécéssaire.


En passant un pointeur, il n"y a plus ce genre de problème mais alors toute modification de la structure passée en argument modifie la structure qui a été passé en argument.

Je pense que tu as compris la différence entre passé une structure et un pointeur de structure mais voilà un exemple de base.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

#include <stdio.h> #include <stdlib.h>   //Définition d'une structure avec un pointeur struct ptr { int *p; };   struct tab { int t[10]; };   //Fonctions f prennent les structures en argument void fptr(struct ptr a) { a.p[0] = 1; //On met 1 à la 1ere case }   void ftab(struct tab a) { a.t[0] = 1; //On met 1 à la 1ere case }   //Fonctions g prennent les pointeurs de structure en argument void gptr(struct ptr *a) { a->p[0] = 2; //On met 2 à la 1ere case }   void gtab(struct tab *a) { a->t[0] = 2; //On met 2 à la 1ere case }   int main() { struct ptr a; struct tab b;   b.t[0] = 0; //On met à 0 a.p = malloc(sizeof(int));   if(a.p==NULL) { printf("Allocation error in main\n"); return EXIT_FAILURE; }   a.p[0] = 0; //On met à 0   fptr(a); ftab(b);   printf("Après f: %d %d\n",a.p[0],b.t[0]);   gptr(&a); gtab(&b); printf("Après g: %d %d\n",a.p[0],b.t[0]);   return EXIT_SUCCESS; }

---

Qui affiche ceci:

Citation:

---

Après f: 1 0
Après g: 2 2

---

En résumé, si tu sais que tu ne vas pas modifier ta structure, passe le pointeur, cela sera plus rapide lors de multiples appels avec des grosses structures.

Jc

oui merci de tesd explications supplémentaires j'ai bien compris la différence :)

Citation:

---

Envoyé par fearyourself

- Lorsque tu passes une structure à une fonction, il y a une copie superficielle <...>

---

Jolie expression.