Discussion :

[Delnir]

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 :

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

[matafan]

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.

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 :

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

[Delnir]

voilà:

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
 
#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?)

[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 :

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

void initialize(struct ensemble *e)

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

Code :

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

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 :

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

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

[Delnir]

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

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

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

[muslim1987]

salut
l'erreur est du la ligne suivante

Code :

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

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 :

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

'\0'

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

Code :

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

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