[c] liste simplement chainé==> pb [résolu==> merci]

liste simplement chainé==> pb [résolu==> merci] [c] - C - Programmation

Marsh Posté le 16-03-2007 à 22:37:27    

Bonjour,
J'ai un problème avec ceci :

Code :
  1. #include<stdio.h>
  2. #include<stdlib.h>
  4. typedef struct liste
  5. {
  6. int x;
  7. struct liste* next;
  8. }liste;
  11. void ajouteFin(liste *l,int b) /* ajoute un element en fin de liste*/
  12. {
  14. liste *a;
  15. a=malloc(sizeof(liste));
  16. a->x=b;
  17. l->next=a;
  18.         a->next=NULL;
  19. }
  23. void ajouteDebut(liste *l,int b)/* ajoute element en début de liste*/
  24. {
  26. liste *a;
  28. a=malloc(sizeof(liste));
  29. a->x=b;
  30. a->next=l;
  32. l=a;/*pb */
  35. }
  37. int main()
  38. {
  40. liste *l=NULL;
  41. l=malloc(sizeof(liste));
  43. if(l!=NULL)
  44. {
  46.  l->x=1;
  47.  l->next=NULL;
  48.  ajouteDebut(l,4);
  51. }
  53. free(l);
  54. return 0;
  55. }


 
Il ne s'agit que de la manipulation de liste chainé.Le problème ce situe au niveau de l'ajout en début de liste.La procédure ne marche pas ( erreur de segmentation à l'execution) mais je ne comprend pas pourquoi.
Je pense avoir identifié le pb ( au niveau de l'affectation l=a), mais je ne comprend pas pourquoi ça foire.
 
Si quelqu'un avait la gentillesse de m'aider ....
 
 
Pour info, compilé avec gcc 4.1.2 sous ubuntu edgy eft.
Merci d'avance

Message cité 1 fois
Message édité par castorgris le 18-03-2007 à 18:21:50
Reply

Marsh Posté le 16-03-2007 à 22:37:27   

Reply

Marsh Posté le 16-03-2007 à 22:42:33    

pour modifier un pointeur, il est de bon aloi d'utiliser un pointeur de pointeur :o
 
Ta fonction ajouteDebut ne modifie en rien ta liste dans ton main

Reply

Marsh Posté le 16-03-2007 à 22:48:25    

Un pointeur de pointeur ? c'est quoi cet animal ?  
Dois-je ecrire :
 
void ajouteDebut(liste **l,int b)
?

Message cité 1 fois
Message édité par castorgris le 16-03-2007 à 22:56:41
Reply

Marsh Posté le 16-03-2007 à 23:08:00    

Je te signale aussi que ta fonction ajouteFin ne fonctionne pas non plus. (en plus de ne pas initialiser a->next à NULL).
Il faut tester le retour des malloc et enfin, en C, on ne caste pas les malloc.

Message cité 1 fois
Message édité par Trap D le 16-03-2007 à 23:09:45
Reply

Marsh Posté le 16-03-2007 à 23:14:50    

Trap D a écrit :

Je te signale aussi que ta fonction ajouteFin ne fonctionne pas non plus. (en plus de ne pas initialiser a->next à NULL).
 


Effectivement, mais c'est juste un couper coller malheureux

 
Trap D a écrit :


Il faut tester le retour des malloc


C'est à dire?

 


le castage ( heu... ça existe ?) des malloc vient aussi d'un oubli de modif du code pour repassage de c++ en c parcque pour une raison que j'ignore, un printf("%d", (l->next)->next) me donne une erreur de segmentation, mais pas un cout << (l->next)->x, sur les compilateur de mon ecole.


Message édité par castorgris le 16-03-2007 à 23:20:13
Reply

Marsh Posté le 16-03-2007 à 23:54:01    

Tu peux fort bien ne plus avoir de mémoire à ta disposition, aussi l'alllocation mémoire peut échouer et la fonction malloc te renvoie NULL. Donc, il faut tester le retour.

Reply

Marsh Posté le 17-03-2007 à 12:35:04    

castorgris a écrit :

Un pointeur de pointeur ? c'est quoi cet animal ?  
Dois-je ecrire :
 
void ajouteDebut(liste **l,int b)
?


http://mapage.noos.fr/emdel/notes. [...] e_variable
 


---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 17-03-2007 à 22:32:11    

castorgris a écrit :

Bonjour,
J'ai un problème avec ceci :

Code :
  1. #include<stdio.h>
  2. #include<stdlib.h>
  4. typedef struct liste
  5. {
  6. int x;
  7. struct liste* next;
  8. }liste;
  11. void ajouteFin(liste *l,int b) /* ajoute un element en fin de liste*/
  12. {
  14. liste *a;
  15. a=malloc(sizeof(liste));
  16. a->x=b;
  17. l->next=a;
  18.         a->next=NULL;
  19. }
  23. void ajouteDebut(liste *l,int b)/* ajoute element en début de liste*/
  24. {
  26. liste *a;
  28. a=malloc(sizeof(liste));
  29. a->x=b;
  30. a->next=l;
  32. l=a;/*pb */
  35. }
  37. int main()
  38. {
  40. liste *l=NULL;
  41. l=malloc(sizeof(liste));
  43. if(l!=NULL)
  44. {
  46.  l->x=1;
  47.  l->next=NULL;
  48.  ajouteDebut(l,4);
  51. }
  53. free(l);
  54. return 0;
  55. }



Très gros problème de conception dans ce code
1) dans le main, tu fais "l=malloc()" => ok
2) ensuite, tu fais "ajouteDebut(l, 4) et dans la fonction "ajouteDebut", tu cherches à faire "a=malloc()" puis "l=a" => donc tu remplaces le résultat de ton malloc initial par le second malloc => t'as perdu ton pointeur initial !!!
Accessoirement, comme l'a dit Joel F, pour modifier une variable dans une fonction, il faut passer l'adresse de cette variable à la fonction qui la stocke dans un pointeur sur cette variable. Donc si tu veux modifier "l" qui est de type "liste *", tu dois passer "&l" à ta fonction qui la stockera dans un "liste **". Ensuite, dans ta fonction "ajouteDebut()", chaque fois que tu veux t'adresser à ton pointeur, tu dois utiliser "*l". Mais de toute façon, même si tu écris correctement ta fonction d'un point de vue syntaxique, tu planteras ton programme car tu perdras ton malloc initial.
 
Question: Pourquoi faire plein de malloc ? Pourquoi ne pas adopter un comportement "objet" qui serait "j'écris une fonction qui alloue de la mémoire et me remplis mon élément avec ma valeur et qui me renvoie l'adresse allouée" puis faire "j'appelle cette fonction quand j'ne ai besoin et j'insère l'élément alloué là où il faut"
 
Par exemple un truc de ce style

Code :
  1. liste* remplir(int val)
  2. {
  3.     liste* elem;
  4.     elem=malloc(sizeof(liste));
  5.     if (elem == NULL)
  6.       return NULL;
  8.     elem->x=val;
  9.     elem->next=NULL;
  10.     return elem;
  11. }
  13. void ajouteDebut(liste** maListe, liste* elem)
  14. {
  15.      if (*maListe == NULL)
  16.      {
  17.           *maListe=elem;
  18.           return;
  19.      }
  21.       elem->next=(*maListe);
  22.       *maListe=elem;
  23. }
  25. void ajouteFin(liste** maListe, liste* elem)
  26. {
  27.      liste *cur;
  29.      if (*maListe == NULL)
  30.      {
  31.           *maListe=elem;
  32.           return;
  33.      }
  35.      for (cur=(*maListe); cur->next != NULL; cur=cur->next);
  36.      cur->next=elem;
  37. }
  39. void videListe(liste* maListe)
  40. {
  41.     liste* cur;
  43.     if (maListe == NULL)
  44.        return;
  46.     for (cur=maListe->next; cur != NULL; cur=cur->next)
  47.     {
  48.          free(maListe);
  49.          maListe=cur;
  50.      }
  51. }
  53. int main()
  54. {
  55.       liste* l=NULL;
  56.       liste* elem;
  58.       elem=remplir(4);
  59.       if (elem != NULL)
  60.       {
  61.           ajouteDebut(&l, elem);
  62.           videListe(l);
  63.       }
  64.       return 0;
  65. }


 
C'est déjà un bon début. Ensuite, je ferais une différenciation entre "type élément" et "type liste" en créant des conteneurs spécialisés pour chacun. Ainsi, je pourrais manipuler plus facilement la liste en elle-même et/ou chaque élément qui la compose. Et je pourrais agrémenter la liste d'autres trucs utiles comme par exemple "nb d'éléments" ou "premier et dernier" ou autres outils...


Message édité par Sve@r le 17-03-2007 à 22:35:04

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.
Reply

Marsh Posté le 18-03-2007 à 18:21:09    

Merci de passer du temps sur ça.
Ce petit bout de code est un exercie pour nous apprendre à manipuler des pointeurs.
Après moult tentative, j'en suis arrivé à  

Code :
  1. liste * ajouteDebut(liste* l, int valeur)
  2. {
  4.     liste* tmp = malloc(sizeof(liste));
  5.     tmp->x = valeur;
  6.     tmp->next = l;
  7.     return tmp;
  8. }


 
qui marche sans pb.Maiis j'ai changais d'approche par rapport à ce que j'avais ecrit au début.
Par contre je ne gère pas la liberation mémoire de tmp.
 
Merci pour ta solution sve@r, qui me semble bien plus "propre" et   moins maladroite .
 
Il faut que j'apprenne à utiliser l'approche objet du langage, parceque moi j'ai tendance à ecrire du code parfois fonctionnel ( souvent non ...) en barbare, surtout que l'usage que j'ai ( et que j'aurais)  est un usage "calcul".Je ne coderais jamais une application, mais des fonctions d'integration numérique si .
 
Merci pour l'aide.
je repasserais surement bientôt pour un autre problème ....

Message cité 3 fois
Reply

Marsh Posté le 18-03-2007 à 23:18:36    

castorgris a écrit :


parceque moi j'ai tendance à ecrire du code parfois fonctionnel


 
Le mot que tu cherche, c'est pas plutôt "impérative" ;) ?
 
http://fr.wikipedia.org/wiki/Progr [...] ctionnelle
http://fr.wikipedia.org/wiki/Progr [...] 3%A9rative
 
:)

Message cité 1 fois
Reply

Marsh Posté le 18-03-2007 à 23:18:36   

Reply

Marsh Posté le 18-03-2007 à 23:32:23    

castorgris a écrit :

Il faut que j'apprenne à utiliser l'approche objet du langage


http://mapage.noos.fr/emdel/tad.htm

Message cité 1 fois

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 19-03-2007 à 07:24:21    

Joel F a écrit :

Le mot que tu cherche, c'est pas plutôt "impérative" ;) ?
 
http://fr.wikipedia.org/wiki/Progr [...] ctionnelle
http://fr.wikipedia.org/wiki/Progr [...] 3%A9rative
 
:)


 
Par fonctionnel je voulais dire "qui marche"...

Reply

Marsh Posté le 19-03-2007 à 07:24:54    

Emmanuel Delahaye a écrit :

http://mapage.noos.fr/emdel/tad.htm


 
 
Merci.Dès que j'ai un moment de libre j'irais voir.


Message édité par castorgris le 19-03-2007 à 07:25:11
Reply

Marsh Posté le 19-03-2007 à 16:17:30    

castorgris a écrit :

Merci de passer du temps sur ça.
Ce petit bout de code est un exercie pour nous apprendre à manipuler des pointeurs.
Après moult tentative, j'en suis arrivé à  

Code :
  1. liste * ajouteDebut(liste* l, int valeur)
  2. {
  4.     liste* tmp = malloc(sizeof(liste));
  5.     tmp->x = valeur;
  6.     tmp->next = l;
  7.     return tmp;
  8. }


 
qui marche sans pb.


 
Ca marche sans problème à condition que, dans la fonction appelante, tu imposes que ta liste récupère ce que renvoie ta fonction "ajouteDebut" sinon ton début ne changera pas. C'est un défaut de conception car ta fonction qui est sensée ajouter un élément au début de la liste ne le fait en fait pas. C'est ta façon de récupérer ce qu'elle renvoie qui fera que ça marche ou pas...
 
Je vais te donner un début de code. Essaye de le comprendre pour le compléter ensuite avec les fonctions qui t'intéressent...

typedef struct elem {
    int x;
    struct elem *next;
} t_elem;
 
typedef struct {
    t_elem *debut;
} t_liste;
 
void listeInit(t_liste *liste)
{
    liste->debut=NULL;
}
 
int main()
{
    t_liste maListe;
    listeInit(&maListe);
 
    return 0;
}


Message édité par Sve@r le 19-03-2007 à 16:18:56

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed