Les structures en C

Version imprimable

Les structures en C

Bonsoir,
j'ai quelque question concernant les structures, d'abord quand doit-je mettre "struct ensemble *e" et "struct ensemble e" dans mon argument de fonction?
(*e quand je doit modifier un élément de la structure c'est bien sa?)
ensuite, voici un exercice:
Définir une structure ensemble permettant la gestion d'un ensemble d'éléments et une fonction size retournant le nombre d'éléments d'un ensemble.

erreur de compilation, je ne comprend pas bien le fonctionnement des structures.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 include<stdlib.h> #include<stdio.h> struct ensemble{ int tab[50]; int nbElt; }; void initialize(struct ensemble *e){ e->nbElt=0; } int size(struct ensemble e){ return e.nbElt; } int main(void){ struct ensemble *e; initialize(&e); printf("nombre d'éléments:%d",size(e)); return 0; }
merci d'avance pour votre aide.

Citation:

Envoyé par Delnir

Bonsoir,
j'ai quelque question concernant les structures, d'abord le "." permet de lire un élément de la structure et "->" de le modifier c'est bien sa?

Non, pas du tout. Le point (.) permet d'accéder à un champ d'une structure. La flèche (->) permet d'accéder à un champ d'une structure à partir d'un pointeur vers cette structure. En fait my_struct_prt->my_field est équivalent à (*my_struct_ptr).my_field.
Citation:
Envoyé par Delnir
ensuite, voici un exercice:
Définir une structure ensemble permettant la gestion d'un ensemble d'éléments et une fonction size retournant le nombre d'éléments d'un ensemble.

erreur de compilation, je ne comprends pas bien le fonctionnement des structures.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 include<stdlib.h> #include<stdio.h> struct ensemble{ int tab[50]; int nbElt; }; void initialize(struct ensemble *e){ e->nbElt=0; } int size(struct ensemble *e){ return e.nbElt; } int main(void){ struct ensemble *e; initialize(&e); printf("nombre d'éléments:%d",size(&e)); return 0; }
merci d'avance pour votre aide.
Plusieurs commentaire :

1) Dans ton code, e est un pointeur vers uns structure. Mais il pointe "dans le vide". Avant de t'en servir, il faut allouer de la mémoire (malloc). L'autre solution est d'utiliser un struct ensemble plutôt qu'un struct ensemble.

2) e est un struct ensemble *, donc quand tu passes &e à initialize(), tu passes un struct ensemble **. C'est n'est pas correct puisque initialize() attend un struct ensemble *. Il faut soit que tu passe directement e si e est un struct ensemble *, soit faire de e un struct ensemble pour effectivement passer &e comme tu le fais. Même commentaire pour l'appel à size().

3) return e.nbElt n'est pas correct. e est un struct ensemble *, donc il faut utiliser -> plutôt que . : return e->nbElt;

voilà:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include<stdlib.h> #include<stdio.h> struct ensemble{ int tab[50]; int nbElt; }; void initialize(struct ensemble *e){ e->nbElt=0; } int size(struct ensemble e){ return e.nbElt; } int main(void){ struct ensemble e; initialize(&e); printf("nombre d'éléments:%d",size(e)); return 0; }
j'avais modifier ma question avant ton poste:
j'ai quelque question concernant les structures, d'abord quand doit-je mettre "struct ensemble *e" et "struct ensemble e" dans mon argument de fonction?
(*e quand je doit modifier un élément de la structure c'est bien sa?)

24/11/2008, 20h43
matafan
Ce que tu dis n'est pas vraiment faux, mais en pratique on ne passe jamais une strucure à une fonction. On passe toujours un pointeur vers la strucure (c'est à dire l'adresse de la structure).

La raison est que si tu passes la structure directement, ça oblige à copier toute la structure sur la stack pour la passer à la fonction. Si au contraire tu passes un pointeur vers la structure, seul un pointeur (4 ou 8 octets, typiquement) est passé via la stack (ou via un registre d'ailleurs, suivant les architectures). Il est donc beaucoup plus efficace de passer un pointeur qu'une structure.

Par contre évidemment passer un pointeur vers une structure permet à la fonction appelée de modifier la structure dans l'appelant. C'est pour ça que le C a prévu le mot clée "const", qui permet (entre autre) de dire que la fonction ne va pas modifier ce qui est pointé par le pointeur que tu lui passes en argument.

Donc pour conclure, on passe toujours un pointeur vers la strucutre. Si la fonction appelée doit modifier la structure dans l'appelant, comme le fait ta fonction initialize, on la déclare comme ceci :

Code:

void initialize(struct ensemble *e)

Si par contre elle ne modifie pas la structure, comme ta fonction size, on fait comme celà :

Code:

int size(const struct ensemble *e)

Le "const" signifie "size() ne modifie pas ce qui est pointé par e" (et fait pas tout à fait, ça veut dire "e est un pointeur vers une structure ensemble qui est constante").

Et les deux foncitons s'appellent de la même manière :
Code:

1 2 initialize(&e); printf("nombre d'éléments: %d\n", size(&e));

Ok merci matafan !
j'ai un autre problème:

L'erreur vien normalement à l'endroit indiqué (erreur de compilation à ce moment) mais je ne comprend absolument pas pourquoi 8O

*la fonction remplir me permet de remplir le tableau et de modifier le nombre d'élement en fonction de sa.*

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
 
#include<stdlib.h>
#include<stdio.h>
 
 struct ensemble{
  int tab[5];
  int nbElt;
 };
 
void initialize(struct ensemble *e){
  e->nbElt=0;
}
 
int size(struct ensemble e){
  return e.nbElt;
}
 
void remplir(struct ensemble *e){
  int i=0,n;
  while(e->tab[i]!='\0'){ 
    printf("saisir un nombre:");
    scanf("%d",&n);
    e->tab[i]=n; 
    e->nbElt++; /*erreur probablement ici*/
    i++; 
  }
}
 
void affiche(struct ensemble e){
  int i=0;
  while(i<e.nbElt){ 
     printf("%d\n",e.tab[i]); 
     i++; 
  }
}
 
int belong(struct ensemble e, int x){
  int res=0,i=0;
  while(i<e.nbElt){ 
    if(e.tab[i]==x) return 1;
    i++; 
  }
  return 0;
}
 
/*void add(struct ensemble *e,int nb){
  if(*/
 
 
int main(void){
  struct ensemble e;
  int x;
  initialize(&e);
  printf("nombre d'éléments:%d\n",size(e));
  remplir(&e);
  affiche(e);
  printf("saisir un entier");
  scanf("%d",&x);
  if(belong(e,x)) printf("%d appartient à l'ensemble E \n",x);
  else printf("%d n'appartient pas à l'ensemble E \n",x);
  return 0;
}

ps:je n'est pas utilisé le const comme tu me la indiqué étant donné que mon professeur ne l'utilise jamais dans le type d'exemple que tu ma montré.

24/11/2008, 22h24
muslim1987
salut
l'erreur est du la ligne suivante

Code:

e->tab[i]!='\0'

test de comparaison entre un caractere et un entier

tous d'abord un tableau d'entier n'est pas un tableau de caractere (il n'a pas une marque de fin comme une chaine

Code:

'\0'

alors pour remplir un tableau d'entier il faut faire le test sur le nombre de case de tableau
Code:

1 2 3 4 5 6 7 8 9 10 11 12 while(i!=5){ printf("saisir un nombre:"); scanf("%d",&n); e->tab[i]=n; e->nbElt++; i++; } //ou for(i=0;i<5;i++) { //les instructions }
bon courage

Ok merci !
j'ai fait une version plus adpaté à ce que je voulai faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void remplir(struct ensemble *e){ int i=0,n; char res='Y'; while((res!='N') && (i<10)){ printf("saisir un nombre:"); scanf("%d",&n); e->tab[i]=n; e->nbElt++; i++; printf("voulez vous ajouter un autre entier? (Y/N)\n"); scanf("%c",&res); } }
Le soucis la c'est que les printf et scanf ce mélange 8O ce qui donne n'inporte quoi !
sur le terminal : saisir un nombre:1
voulez vous ajouter un autre entier? (Y/N):saisir un nombre:Y
voulez vous ajouter un autre entier? (Y/N):saisir un nombre:N

24/11/2008, 23h51
matafan

Toujours faire un fflush(stdout) après un printf qui ne se termine pas par un '\n'.

Citation:

Envoyé par matafan

Toujours faire un fflush(stdout) après un printf qui ne se termine pas par un '\n'.

Oui, mais le problème n'est pas là. Le problème est récurrent. Il est dû comme d'habitude à une utilisation naïve d'une fonction complexe comme scanf()...

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
 
#include <stdio.h>
 
struct ensemble
{
   int tab[50];
   int nbElt;
};
 
static void purge (void)
{
   int c;
   while ((c = getchar ()) != '\n' && c != EOF)
   {
   }
}
 
void remplir (struct ensemble e[], size_t n)
{
   int i = 0, n;
   char res = 'Y';
 
   while (res != 'N' && i < n)
   {
      printf ("saisir un nombre:");
      scanf ("%d", &n);
      purge ();
      e->tab[i] = n;
      e->nbElt++;
      i++;
      printf ("voulez vous ajouter un autre entier? (Y/N)\n");
      scanf ("%c", &res);
      if (res != '\n')
      {
         purge ();
      }
   }
}
 
int main (void)
{
   struct ensemble e[3];
   remplir (&e, 3);
   return 0;
}