Pointeurs et structures... [Débutant(e)]

**vinzzzz** · 17/01/2006, 20h33

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**ShootDX** · 17/01/2006, 20h46

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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().

**vinzzzz** · 17/01/2006, 20h51

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

**hegros** · 17/01/2006, 21h09

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

**vinzzzz** · 17/01/2006, 21h42

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

**hegros** · 17/01/2006, 21h51

Il sort d'ou pop ? Bob ?

**vinzzzz** · 17/01/2006, 21h53

lol dsl erreur de frappe c'est modifié

**hegros** · 17/01/2006, 21h56

Il te manque une parenthése fermante ')'

**vinzzzz** · 17/01/2006, 22h01

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 
}

**hegros** · 17/01/2006, 22h05

EDIT : j'ai dis une connerie

**vinzzzz** · 17/01/2006, 22h12

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

gp.indivs[i]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

n'est pas équivalente à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**fearyourself** · 18/01/2006, 09h53

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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:

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