structures imbriqués fonctions

Version imprimable

Bonjour,

Je voudrais accéder à une cellule d'une structure imbriqué dans une autre, grâce a une fonction. Comment faire?

Voici mes structures:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 struct eleve { char nom[100]; char prenom [100]; int age; }; struct nClass { char nom[5]; char maitresse [26]; struct eleve tableEleves [32]; };
et voici ma fonction à modifer (initialement ecrite pour utiliser seulement la structure eleve):
Code:

1 2 3 4 5 6 void Afficher_Eleve ( struct nClass param) { printf ("Nom = %-10.10s | ",param.nom); printf ("Prenom = %-10.10s | ",param.prenom); printf ("Age = %d\n",param.age); }
Comment appeler dans mon main?

Citation:

Envoyé par B65AcR

et voici ma fonction à modifer (initialement ecrite pour utiliser seulement la structure eleve):

Code:

1
2
3
4
5
6
void Afficher_Eleve ( struct nClass param)
  {
  printf ("Nom = %-10.10s | ",param.nom);
  printf ("Prenom = %-10.10s | ",param.prenom);
  printf ("Age = %d\n",param.age);
  }

Bonjour

Code:

1
2
3
4
5
6
7
8
9
10
11
12
void Afficher_Eleve ( struct nClass *param)
{
  struct eleve *elv;
  size_t i;
  for (i=0, elv=param->tableEleves; i < 32; i++, elv++)
  {
      printf("Eleve %d\n", i+1);
      printf ("Nom = %-10.10s | ", elv->nom);
      printf ("Prenom = %-10.10s | ", elv->prenom);
      printf ("Age = %d\n", elv->age);
  }
}

Citation:

Envoyé par B65AcR

Comment appeler dans mon main?

Code:

1
2
3
4
5
int main()
{
    struct nClass classe;
    Afficher_Eleve(&classe);
}

Super! Merci!

Par contre je ne suis pas super a l'aise avec les pointeurs. Il n'y aura pas une autre solution avec un truc dans ce genre:
Code:

1 2 3 4 5 6 void Afficher_Eleve ( struct nClass param[i]) { printf ("Nom = %-10.10s | ",param[i].nom); printf ("Prenom = %-10.10s | ",param[i].prenom); printf ("Age = %d\n",param[i].age); }

08/12/2013, 15h37
Sve@r
Citation:

Envoyé par B65AcR

Super! Merci!

Par contre je ne suis pas super a l'aise avec les pointeurs.

Hé ben il faut t'y mettre sérieusement. Ou alors abandonner le C...
Citation:
Envoyé par B65AcR

Il n'y aura pas une autre solution avec un truc dans ce genre:

Code:

1 2 3 4 5 6 void Afficher_Eleve ( struct nClass param[i]) { printf ("Nom = %-10.10s | ",param[i].nom); printf ("Prenom = %-10.10s | ",param[i].prenom); printf ("Age = %d\n",param[i].age); }
Ouais bon faut vraiment t'y mettre!!!

Que reçoit la fonction ? L'adresse d'une structure (&classe). Elle stockera cette adresse dans un pointeur (*param). Ce pointeur pointe vers une structure classe => struct classe *param.

Comment on accède aux membres d'une structure pointée ? Par le biais de la flèche -> (parce que la priorité des opérateurs impose, sinon, de taper (*param).membre ce qui devient vite chiant). Toi tu veux accéder à chaque élément "i" de ton tableau d'élèves => param->tabEleves[i].
Une fois que tu as chaque élément "i", tu veux taper dans le nom et autres membres => param->tabEleves[i].nom.

A partir de là, c'est fini, t'as tout ce qu'il faut. Tout ce que j'ai fait, moi, c'est de remplacer tabEleves[i] par un autre pointeur "elv" pour optimiser les accès. Et comme tabEleves[i].nom <=> *(elv + i).nom et que (*elv).nom <=> elv->nom alors tabEleves[i].nom <=> elv->nom. Mais si c'est trop ardu alors tu remplaces dans mon code elv->truc par param->tabEleves[i].truc. C'est méga plus long à s'exécuter (un déréférencement plus un index plus un autre déréférencement et ça à chaque printf) mais c'est pareil au niveau du résultat...
08/12/2013, 21h35
B65AcR

Wow! Plus ardu, mais j'ai compris! Et c'est super interessant a lire quand tu es debutant.

C'est quoi un déréférencement?

A tout niveau il vaut mieux declarer un pointeur que d'écrire "param->tabEleves[i].truc" ?

Il y a une ligne que je ne comprends absolument pas:

Code:

size_t i

ça veut dire quoi? size sort d'ou?

Sinon j'ai fait ça:

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
 
# include<stdio.h>
# include<string.h>
 
struct eleve
  {
    char nom[100];
    char prenom [100];
    int age;
  };
 
struct nClass
	{
		char nom[5];
		char maitresse [26];
		struct eleve tableEleves [32];
	};
 
void Afficher_Eleve ( struct nClass param,int i);
 
main ()
{
 
  struct eleve Moi = {"yop","la",1};
  struct nClass test;
 
 Afficher_Eleve (test,0);
 
}
 
void Afficher_Eleve ( struct nClass param, int i)
  {
  printf ("Nom = %-10.10s | ",param.tableEleves[i].nom);
  printf ("Prenom = %-10.10s | ",param.tableEleves[i].prenom);
  printf ("Age = %d\n",param.tableEleves[i].age);
  }

Qu'en penses tu?

Citation:

Envoyé par B65AcR

C'est quoi un déréférencement?

C'est l'opération que fait le compilo pour atteindre l'élément tab[x] ou elem.elem.elem.data ou autres opérations similaires.
Dans chaque cas il part du début de la zone puis se déplace du nombre d'octets voulus pour atteindre la cible demandée.
Et ce genre d'opération est toujours super longue donc si t'as besoin de la faire plusieurs fois vaut mieux créer un pointeur intermédiaire...

Citation:

Envoyé par B65AcR

A tout niveau il vaut mieux declarer un pointeur que d'écrire "param->tabEleves[i].truc" ?

Uniquement si t'as besoin d'accéder plusieurs fois à tabEleves[i]...

Citation:

Envoyé par B65AcR

Il y a une ligne que je ne comprends absolument pas:

Code:

size_t i

ça veut dire quoi? size sort d'ou?

C'est un type rajouté dans la libC pour manipuler les index de tableaux. On peut le remplacer par short ou long ou, mieux unsigned short/long mais l'avantage du size_t c'est qu'il évolue avec le C...
Citation:
Envoyé par B65AcR
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 # include<stdio.h> # include<string.h> struct eleve { char nom[100]; char prenom [100]; int age; }; struct nClass { char nom[5]; char maitresse [26]; struct eleve tableEleves [32]; }; void Afficher_Eleve ( struct nClass param,int i); main () { struct eleve Moi = {"yop","la",1}; struct nClass test; Afficher_Eleve (test,0); } void Afficher_Eleve ( struct nClass param, int i) { printf ("Nom = %-10.10s | ",param.tableEleves[i].nom); printf ("Prenom = %-10.10s | ",param.tableEleves[i].prenom); printf ("Age = %d\n",param.tableEleves[i].age); }
Qu'en penses tu?
Ta fonction d'affichage est correcte. Mon code affiche tout le tableau, la tienne n'affiche que l'élève x. Le fait de préférer l'une ou l'autre dépend de ton besoin.
Toutefois faut quand-même recopier le contenu de "Moi" dans "test.tabEleves[0]" pour que l'exécution produise un résultat visible correct (pour un test rapide on peut utiliser memcpy mais pour une portabilité complète faut le faire membre par membre).

Voici cependant un petit correctif indispensable
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 void Afficher_Eleve ( struct nClass *param, size_t i) { printf ("Nom = %-10.10s | ",param->tableEleves[i].nom); printf ("Prenom = %-10.10s | ",param->tableEleves[i].prenom); printf ("Age = %d\n",param->tableEleves[i].age); } main () { struct eleve Moi = {"yop","la",1}; struct nClass test; // Recopie de Moi dans test.tabEleves[0] memcpy(&test.tabEleves[0], &Moi, sizeof (struct eleve)); Afficher_Eleve (&test,0); }
En effet, comme je l'ai dit, c'est plus rapide de passer l'adresse d'une structure que de passer la structure elle-même.
Autre remarque: la fonction "afficher" n'utilisant que des éléments de tabEleves aurait pu se contenter de recevoir un pointeur sur ce membre (au lieu de recevoir un pointeur vers struct nClass). Mais telle qu'elle est cela ne pose pas de pb et permet ensuite de la faire évoluer plus facilement...

09/12/2013, 10h13
Physics
Bonjour,
Citation:
Envoyé par B65AcR

Super! Merci!

Par contre je ne suis pas super a l'aise avec les pointeurs. Il n'y aura pas une autre solution avec un truc dans ce genre:

Code:

1 2 3 4 5 6 void Afficher_Eleve ( struct nClass param[i]) { printf ("Nom = %-10.10s | ",param[i].nom); printf ("Prenom = %-10.10s | ",param[i].prenom); printf ("Age = %d\n",param[i].age); }
Généralement, lorsque le type de l'argument d'une fonction a une taille supérieure à celle des entiers, on le passe par pointeur.
Ici les deux structures ont une taille plus grande que celle des entiers, c'est pour cette raison il a utilisé les pointeurs.