un problème de passage de paramétres

Version imprimable

Voir 40 message(s) de cette discussion en une page

Salut ! je veux faire une procédure en C qui défile le premier élément d'une liste chaînée et renvoi ça valeur dans une variable de type entier, sachant que je veux détruire cette élément de la liste âprés avoir récupérer ça valeur.
le probléme c'est que la liste passé en parametre ne change pas, voila le code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 struct elt { int val ; struct elt *suiv ; }; typedef struct elt* liste; void defiler_l_int(liste l,int* x) { liste q = l ; liste p = l; p=l->suiv; if(q!=NULL) {*x=q->val; l=p; q->suiv=NULL; free(q); } }
et quand je fais ça:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void defiler_l_int(liste* l,int* x) { liste q = *l ; liste p = *l; p=l->suiv; if(q!=NULL) {*x=q->val; l=p; q->suiv=NULL; free(q); } }
il y a il erreur qui s'affiche pour me dire que
`suiv' has not been declared
dans l'instruction suivante:

Code:

p=l->suiv;

c'est quoi le problème ! aidez moi svp !

La variable q n'etant pas un pointeur, la comparer a NULL ou tenter de faire un free dessus n'a aucun sens.

Comme ce n'est pas un pointeur, pour acceder a ces elements tu ne dois pas utiliser "->" mais ".".
Code:

1 2 3 4 5 liste *q; q->val; list p; p.val;
Donc reprenons ton code et modifions-le un peu :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void defiler_l_int(liste* l,int* x) { liste *q = l ; liste *p = l->suiv; if (q != NULL) { *x = q->val; l = p; //cette ligne n'a juste aucun sens q->suiv = NULL; //celle-la non plus d'ailleurs... free(q); //pourquoi veux-tu liberer la memoire ici ? } }

30/11/2013, 14h42
Obsidian

Citation:

Envoyé par imperio

La variable q n'etant pas un pointeur, la comparer a NULL ou tenter de faire un free dessus n'a aucun sens.

…

La variable q EST un pointeur !

Comme dans beaucoup d'écoles, on lui apprend à faire ce qu'il ne faut pas faire en C : masquer un pointeur dans un typedef. : typedef struct elt* liste;.
30/11/2013, 14h45
mohsenuss91
@imperio : ok, je veux supprimer à chaque fois le nœud d’où j'ai récupéré la valeur, donc si je récupère toutes la valeurs la liste sera NULL.
mais dans ce code aussi ça m'affiche que :
```
`suiv' has not been declared 
```
pour:

Code:

liste *p = l->suiv;

et que
```
`val' has not been declared 
```
pour:

Code:

*x = q->val;

et que
```
`suivl' has not been declared 
```
pour:

Code:

q->suiv = NULL;

@Obsidian : Que ce que je dois faire!
30/11/2013, 15h59
imperio

Citation:

Envoyé par Obsidian

La variable q EST un pointeur !

Comme dans beaucoup d'écoles, on lui apprend à faire ce qu'il ne faut pas faire en C : masquer un pointeur dans un typedef. : typedef struct elt* liste;.

Oups ! Effectivement je n'avais pas du tout fait gaffe au typedef...

Citation:

Envoyé par mohsenuss91

Que ce que je dois faire!

Réflechir me semble être une bonne piste. Donc la question est plutôt : qu'est-ce que toi tu veux faire ?
30/11/2013, 17h07
mohsenuss91
J'ai pas compris l'erreur suivante
```
 `suiv' has not been declared 
```
malgré que dans la structure le suiv existe!
30/11/2013, 17h21
imperio

Ton erreur decoule directement de la remarque qu'a fait Obsidian.
30/11/2013, 17h38
mohsenuss91

Citation:

Envoyé par Obsidian

La variable q EST un pointeur !

Comme dans beaucoup d'écoles, on lui apprend à faire ce qu'il ne faut pas faire en C : masquer un pointeur dans un typedef. : typedef struct elt* liste;.

Si j’enlève le typedef struct ça marche pas :/

Il ne s'agit pas de faire les choses au hasard et de se lamenter parce que "ça ne marche pas", mais de réfléchir un peu.

La struct elt définit un maillon de la liste.
Code:

1 2 3 4 5 typedef struct elt { int val ; struct elt *suiv ; }Maillon;
Maintenant, il faut définir la liste. On peut se contenter d'un pointeur, mais pour la clarté, il convient de bien distinguer les maillons et la liste (qui est une collection ordonnée de maillons). Une structure a l'avantage d'accentuer son caractère particulier et finalement la clarté du code. De plus, on pourra éventuellement y ajouter d'autres informations qui peuvent apparaitre utiles (pointeur de queue, nombre d'éléments,...)
Code:

1 2 3 4 typedef struct { Maillon * tete; } Liste;
A noter que cela respecte le critère d'Obsidian puisque maintenant Liste n'est pas un pointeur mais un struct

Maintenant, on peut discuter de la fonction defiler_l_int():
-A- Si la liste est vide ne rien faire (discutable )
-B- Sinon
---1- Renvoyer la valeur stockée dans la cellule de tête de la liste
---2- Sauver la position de la cellule suivant la cellule de tête
---3- Détruire la cellule de tête
---4- La nouvelle tête de liste est celle dont on a sauvé la position

B4 modifie la tête de liste, donc on doit avoir l'adresse de la liste pour opérer cette modification. Le prototype de la fonction doit être

Code:

void defiler_l_int(Liste * l,int * x)

En ne s'occupant pas (pour l'instant) de l'étape A, on a alors
Code:

1 2 3 4 5 6 7 8 9 void defiler_l_int(Liste * l,int * x) { Maillon suivant; //si la liste n'est pas vide : *x = l->tete->val; suivant = l->tete->suiv; free(l->tete); l->tete = suivant; }
L'étape A est discutable, car comment savoir que la valeur obtenue (normalement retournée par *x) n'est pas n'importe quoi ce qui serait le cas si la liste était vide. On sera donc amené de toute façon à tester si la liste est vide avant l'appel de la fonction ou à tester si la valeur retournée est valide après l'appel à cette fonction (qui alors doit retourner un indicateur)
Dans cette dernière option,le prototype serait
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 int defiler_l_int(Liste * l,int * x) { Maillon * suivant; if(l==NULL || l->tete==NULL) return 0; *x = l->tete->val; suivant = l->tete->suiv; free(l->tete); l->tete = suivant; return 1; } //------------------------ Liste liste = {NULL}; int x; //.... Ajouter des éléments à la liste while(defiler_l_int(&liste, &x)) { printf("%d \n",x); }

02/12/2013, 10h01
Médinoc

Je confirme, le typedef chainon *liste; est une horreur qui cause bien plus de problèmes qu'elle n'en résout. La méthode de diogene, avec une structure pour le chaînon et une pour la liste, est bien plus compréhensible.

J'ai essayé avec ç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
37
38
39
40
41
42
43
 
#include<stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
typedef struct elt
{
    int val ;
    struct elt *suiv ;
}Maillon;
 
 
typedef struct
{
   Maillon * tete;
} Liste;
 
 
int defiler_l_int(Liste * l,int * x)
{
  Maillon * suivant;
  if(l==NULL || l->tete==NULL) return 0;
  *x = l->tete->val;
  suivant = l->tete->suiv;
  free(l->tete);
  l->tete = suivant;
  return 1;
}
//------------------------
 
 
main()
{   Liste l = {NULL},p;
p=(Liste) malloc(sizeof(struct Liste));
    p->tete->val=6;
   int x;
  //.... Ajouter des éléments à la liste
   while(defiler_l_int(&l, &x))
   {
      printf("%d \n",x);
   }
    getch();
    }

et il y a des problémes:
invalid application of `sizeof' to incomplete type `Liste' |
conversion to non-scalar type requested|
invalid type argument of `->'|
au niveau de:

Code:

p=(Liste) malloc(sizeof(struct Liste));

03/12/2013, 15h47
imperio
L'erreur vient de ces lignes :
Code:

1 2 3 4 typedef struct { Maillon * tete; } Liste;
De plus, dans ton sizeof tu peux tres bien faire ca :

Code:

p = malloc(sizeof(*p));

Si tu as besoin de caster le retour de malloc, c'est que tu utilises un compilateur c++.
03/12/2013, 15h59
mohsenuss91
ok,
j'ai fais ça:
Code:

1 2 3 4 typedef struct Liste { Maillon * tete; } Liste;
mais il y a toujours un problème invalid type argument of `unary * au niveau de:

Code:

p = malloc(sizeof(*p));
03/12/2013, 16h29
imperio

C'est parce que tu tentes d'allouer de la memoire a une variable qui n'est pas un pointeur...

Code:

1 2 3 4 main() { Liste l = {NULL},p; p=(Liste) malloc(sizeof(struct Liste)); ....
1- on DOIT spécifier le type de retour des fonctions : int main() , mais ce n'est pas la cause du problème

2- struct Liste n'existe pas : C'est Liste qui existe

3- p est un Liste qui n'est pas un pointeur mais un struct. Comme malloc renvoie une adresse, il faut la stocker dans un pointeur.

4- Si on veut construire un programme, il faut penser à le structurer en taches élémentaires qui peuvent être testées indépendamment les unes des autres avant d'être utilisées et réutilisées pour élaborer des taches plus complexes. De plus, cela permet de savoir où se trouve le code qui effectue une tache donnée ce qui est très utile pour la conception, la mise au point, l'évolution future et la maintenance du programme.

Si on veut créer un maillon et le mettre dans la liste, on peut faire par exemple:
Code:

1 2 3 4 5 6 int main() { Liste liste = {NULL}; // création d'une liste vide Maillon *p = creerMaillon(6); ajouterMaillon(&liste,p); ...
Et écrire les fonctions creerMaillon() et ajouterMaillon()
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Maillon * creerMaillon(int data) { Maillon * p = malloc(sizeof *p); if(p != NULL) { p->suiv = NULL; p->val = data; } return p; } void ajouterMaillon(Liste * liste, Maillon * maillon) { if (liste == NULL || maillon == NULL) return; // Ajouter le maillon en tête de la liste; // ..... }

J'ai essayé avec cet exemple:

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
 
typedef struct elt
{
    int val ;
    struct elt *suiv ;
}Maillon;
 
 
typedef struct
{
   Maillon* s;
} Liste;
 
 
void defiler_l_int(Liste * l,int * x)
{
  Maillon * suivant;
  if(l!=NULL) {
  *x = l->s->val;
  suivant = l->s->suiv;
  l->s = suivant;
  free(l->s);
  }
}
 
 
 
int main()
{
 Maillon * p = malloc(sizeof *p);
    p->val=6;
    p->suiv=NULL;
   int x=6;
  //.... Ajouter des éléments à la liste
 
   defiler_l_int(p, &x);
      printf("%d \n",x);
 
getch();
    }

mais il y a toujours un problème et d’après le debugger le problème est la:

Code:

*x = l->s->val;

03/12/2013, 17h46
Médinoc

Poste le vrai code, celui qui ajoute vraiment des maillons à la liste.
Parce que pour l'instant, ça plante parce que la liste est vide.
03/12/2013, 18h28
mohsenuss91
Citation:

Envoyé par Médinoc

Poste le vrai code, celui qui ajoute vraiment des maillons à la liste.
Parce que pour l'instant, ça plante parce que la liste est vide.

Mais dans cette partie normalement je crée un maillon (qui est le seul élément de la Liste pour le moment)
Code:

1 2 3 Maillon * p = malloc(sizeof *p); p->val=6; p->suiv=NULL
03/12/2013, 18h35
diogene

Tu ne fais pas attention : il n'y a pas de Liste dans ton programme (d'ailleurs, le compilateur n'a pas dû être d'accord sur le premier argument de l'appel à defiler_l_int() qui n'est pas un Liste *)
03/12/2013, 18h50
mohsenuss91
Citation:

Envoyé par diogene

Tu ne fais pas attention : il n'y a pas de Liste dans ton programme (d'ailleurs, le compilateur n'a pas dû être d'accord sur le premier argument de l'appel à defiler_l_int() qui n'est pas un Liste *)

Euh ! Donc cette structure représente quoi exactement ?
Code:

1 2 3 4 typedef struct { Maillon* s; } Liste;
J'ai essayé avec *Maillon :
Code:

1 2 3 4 5 6 7 8 9 10 void defiler_l_int(Maillon* l,int * x) { Maillon * suivant; if(l!=NULL) { *x = l->val; suivant = l->suiv; l->suiv = suivant; free(l->suiv); } }
Mais ça fonctionne toujours pas !
Quand je fais appel a cette procédure comme ça:

Code:

defiler_l_int(&p, &x);

il y a un warning de type:
passing arg 1 of `defiler_l_int' from incompatible pointer type

et si je fais :

Code:

defiler_l_int(p, &x);

p ne change pas :roll:

Voir 40 message(s) de cette discussion en une page