Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
2453 connectés 

  FORUM HardWare.fr
  Programmation
  C

  comment utiliser deux module liste simple avec une autre application

 



 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

comment utiliser deux module liste simple avec une autre application

n°2132311
mylo07
Etudiant
Posté le 21-03-2012 à 04:31:15  profilanswer
 

salut à tous j ai un sérieux probleme  
 
1 .  j ai un  module LISTE SIMPLE(" liste.h" et "  liste.cpp " )qui effectue  la gestion des listes et qui est très général et peut être utilisé dans de nombreuses applications(le voici ci dessous)
 
 

Code :
  1. // liste.h
  2. #ifndef LISTE_H
  3. #define LISTE_H
  4. #ifdef WINDOWS
  5. #define DllExport   __declspec( dllexport )  // for windows
  6. #else
  7. #define DllExport  // Linux
  8. #endif
  9. #define faux   0
  10. #define vrai   1
  11. typedef int    booleen;
  12. typedef void Objet;
  13. #define NONORDONNE  0
  14. #define CROISSANT   1
  15. #define DECROISSANT 2
  16. // un élément de la liste
  17. typedef struct element {
  18.   Objet*          reference;   // référence un objet (de l'application)
  19.   struct element* suivant;     // élément suivant de la liste
  20. } Element;
  21. // le type Liste
  22. typedef struct {
  23.   Element* premier; // premier élément de la liste
  24.   Element* dernier; // dernier élément de la liste
  25.   Element* courant; // élément en cours de traitement (parcours de liste)
  26.   int      nbElt;   // nombre d'éléments dans la liste
  27.   int      type;    // 0:simple, 1:croissant, 2:décroissant
  28.   char*    (*toString) (Objet*);
  29.   int      (*comparer) (Objet*, Objet*);
  30. } Liste;
  31. DllExport void     initListe              (Liste* li, int type, char* (*toString) (Objet*),
  32.     int (*comparer) (Objet*, Objet*) );
  33. DllExport void     initListe              (Liste* li);
  34. DllExport Liste*   creerListe             (int type, char* (*toString) (Objet*),
  35.     int (*comparer) (Objet*, Objet*) );
  36. DllExport Liste*   creerListe             (int type);
  37. DllExport Liste*   creerListe             ();
  38. DllExport booleen  listeVide              (Liste* li);
  39. DllExport int      nbElement              (Liste* li);
  40. DllExport void     insererEnTeteDeListe   (Liste* li, Objet* objet);
  41. DllExport void     insererEnFinDeListe    (Liste* li, Objet* objet);
  42. // parcours de liste
  43. DllExport void     ouvrirListe            (Liste* li);
  44. DllExport booleen  finListe               (Liste* li);
  45. DllExport Objet*   objetCourant           (Liste* li);
  46. DllExport void     listerListe            (Liste* li);
  47. DllExport void     listerListe            (Liste* li, void (*f) (Objet*));
  48. DllExport Objet*   chercherUnObjet        (Liste* li, Objet* objetCherche);
  49. DllExport Objet*   extraireEnTeteDeListe  (Liste* li);
  50. DllExport Objet*   extraireEnFinDeListe   (Liste* li);
  51. DllExport booleen  extraireUnObjet        (Liste* li, Objet* objet);
  52.  
  53. DllExport void     detruireListe          (Liste* li);
  54. DllExport void     recopierListe          (Liste* l1, Liste* l2);
  55. //Element* pPremier             (Liste* li);
  56. //Element* pDernier             (Liste* li);
  57. //Objet*   pDernier             (Liste* li);
  58. //Element* pSuivant             (Element* elt);
  59. // LISTE ORDONNEE
  60. DllExport void     insererEnOrdre         (Liste* li, Objet* objet);
  61. #endif
Code :
  1. /* liste.cpp
  2.    Ce module de gestion de listes est très général
  3.    et indépendant des applications.
  4.    Il gère des listes simples d'éléments avec tête de liste */
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include "liste.h"
  9. // fonctions locales au module
  10. static Element* creerElement    ();
  11. static void     insererApres    (Liste* li, Element* precedent, Objet* objet);
  12. static Objet*   extraireApres   (Liste* li, Element* precedent);
  13. static Element* elementCourant  (Liste* li);
  14. // comparer deux chaînes de caractères
  15. // fournit <0 si ch1 < ch2; 0 si ch1=ch2; >0 sinon
  16. static int comparerCar (Objet* objet1, Objet* objet2) {
  17.   return strcmp ((char*)objet1,(char*)objet2);
  18. }
  19. static char* toChar (Objet* objet) {
  20.   return (char*) objet;
  21. }
  22. // initialiser la liste pointée par li (cas général)
  23. void initListe (Liste* li, int type, char* (*toString) (Objet*),
  24.      int (*comparer) (Objet*, Objet*)) {
  25.   li->premier  = NULL;
  26.   li->dernier  = NULL;
  27.   li->courant  = NULL;
  28.   li->nbElt    = 0;
  29.   li->type     = type;
  30.   li->toString = toString;
  31.   li->comparer = comparer;
  32. }
  33. // initialisation par défaut
  34. void initListe (Liste* li) {
  35.   initListe (li, NONORDONNE, toChar, comparerCar);
  36. }
  37. Liste* creerListe (int type, char* (*toString) (Objet*),
  38.     int (*comparer) (Objet*, Objet*)) {
  39.   Liste* li = new Liste();
  40.   initListe (li, type, toString, comparer);
  41.   return li;
  42. }
  43. Liste* creerListe (int type) {
  44.   return creerListe (type, toChar, comparerCar);
  45. }
  46. Liste* creerListe () {
  47.   return creerListe (NONORDONNE, toChar, comparerCar);
  48. }
  49. // la liste est-elle vide ?
  50. booleen  listeVide (Liste* li) {
  51.   return li->nbElt == 0;
  52. }
  53. // fournir le nombre d'éléments dans la liste
  54. int nbElement (Liste* li) {
  55.   return li->nbElt;
  56. }
  57. // INSERER UN OBJET DANS UNE LISTE
  58. // insérer objet en tête de la liste li
  59. // l'objet est repéré par le champ reference de l'élément de la liste
  60. void insererEnTeteDeListe (Liste* li, Objet* objet) {
  61.   Element* nouveau   = creerElement();
  62.   nouveau->reference = objet;
  63.   nouveau->suivant   = li->premier;
  64.   li->premier        = nouveau;
  65.   if (li->dernier == NULL) li->dernier = nouveau;
  66.   li->nbElt++;
  67. }
  68. // insérer un objet en fin de la liste li
  69. void insererEnFinDeListe (Liste* li,  Objet* objet) {
  70.   insererApres (li, li->dernier, objet);
  71. }
  72. // PARCOURS DE LISTE
  73. // se positionner sur le premier élément de la liste li
  74. void ouvrirListe (Liste* li) {
  75.   li->courant = li->premier;
  76. }
  77. // a-t-on atteint la fin de la liste li ?
  78. booleen finListe (Liste* li) {
  79.   return li->courant==NULL;
  80. }
  81. // fournir un pointeur sur l'objet courant de la liste li,
  82. // et se positionner sur le suivant qui devient le courant
  83. Objet* objetCourant (Liste* li) {
  84.   Element* ptc = elementCourant (li);
  85.   return ptc==NULL ? NULL : ptc->reference;
  86. }
  87. void listerListe (Liste* li) {
  88.   ouvrirListe (li);
  89.   while (!finListe (li)) {
  90.     Objet* objet = objetCourant (li);
  91.     printf ("%s\n", li->toString (objet));
  92.   }
  93. }
  94. // lister la liste li;
  95. // f est une fonction passée en paramètre  
  96. // et ayant un pointeur de type quelconque.
  97. // Ceci s'apparente aux méthodes virtuelles en PO.
  98. void listerListe (Liste* li, void (*f) (Objet*)) {
  99.   ouvrirListe (li);
  100.   while (!finListe (li)) {
  101.     Objet* objet = objetCourant (li);
  102.     f (objet);  // appliquer la fonction f() à objet
  103.   }
  104. }
  105. // fournir un pointeur sur l'objet "objetCherche" de la liste li;
  106. // NULL si l'objet n'existe pas
  107. Objet* chercherUnObjet (Liste* li, Objet* objetCherche) {
  108.   booleen trouve = faux;
  109.   Objet* objet;       // pointeur courant
  110.   ouvrirListe (li);
  111.   while (!finListe (li) && !trouve) {
  112.     objet  = objetCourant (li);
  113.     trouve = li->comparer (objetCherche, objet) == 0;
  114.   }
  115.   return trouve ? objet : NULL;
  116. }
  117. // EXTRAIRE UN OBJET D'UNE LISTE
  118. // extraire l'objet en tête de la liste li
  119. Objet* extraireEnTeteDeListe (Liste* li) {
  120.   Element* extrait = li->premier;
  121.   if (!listeVide(li)) {
  122.     li->premier = li->premier->suivant;
  123.     if (li->premier==NULL) li->dernier=NULL; // Liste devenue vide
  124.     li->nbElt--;
  125.   }
  126.   return extrait != NULL ? extrait->reference : NULL;
  127. }
  128. // extraire l'objet en fin de la liste li
  129. Objet* extraireEnFinDeListe (Liste* li) {
  130.   Objet* extrait;
  131.   if (listeVide(li)) {
  132.     extrait = NULL;
  133.   } else if (li->premier == li->dernier) {  // un seul élément
  134.     extrait = extraireEnTeteDeListe (li);
  135.   } else {
  136.     Element* ptc = li->premier;
  137.     while (ptc->suivant != li->dernier) ptc = ptc->suivant;
  138.     extrait = extraireApres (li, ptc);
  139.   }
  140.   return extrait;
  141. }
  142. // extraire de la liste li, l'objet pointé par objet
  143. booleen extraireUnObjet (Liste* li, Objet* objet) {
  144.   Element* precedent = NULL;
  145.   Element* ptc       = NULL;
  146.   // repère l'élement précédent
  147.   booleen trouve = faux;
  148.   ouvrirListe (li);
  149.   while (!finListe (li) && !trouve) {
  150.     precedent = ptc;
  151.     ptc       = elementCourant (li);
  152.     trouve = (ptc->reference == objet) ? vrai : faux;
  153.   }
  154.   if (!trouve) return faux;
  155.   Objet* extrait = extraireApres (li, precedent);
  156.   return vrai;
  157. }
  158. // parcours de liste avec destruction de chaque élément
  159. void detruireListe (Liste* li) {
  160.   ouvrirListe (li);
  161.   while (!finListe (li)) {
  162.     Element* ptc = elementCourant (li);
  163.     //free (ptc->reference);  // si on veut détruire les objets de la liste
  164.     free (ptc);
  165.   }
  166.   initListe (li);
  167. }
  168. // recopie l2 dans l1 et initialise l2
  169. void  recopierListe (Liste* l1, Liste* l2) {
  170.   detruireListe (l1);
  171.   *l1 = *l2; // on recopie les têtes de listes
  172.   initListe (l2);
  173. }
  174. // FONCTIONS LOCALES AU MODULE
  175. // créer un élément de liste
  176. static Element* creerElement () {
  177.   //return (Element*) malloc (sizeof (Element));
  178.   return new Element();
  179. }
  180. // insérer  dans la liste li, objet après precedent
  181. // si precedent est NULL, insérer en tête de liste
  182. static void insererApres (Liste* li, Element* precedent, Objet* objet) {
  183.   if (precedent == NULL) {
  184.     insererEnTeteDeListe (li, objet);
  185.   } else {
  186.     Element* nouveau   = creerElement();
  187.     nouveau->reference = objet;
  188.     nouveau->suivant   = precedent->suivant;
  189.     precedent->suivant = nouveau;
  190.     if (precedent == li->dernier) li->dernier = nouveau;
  191.     li->nbElt++;
  192.   }
  193. }
  194. // Extraire l'objet de li se trouvant après l'élément precedent;
  195. // si precedent vaut NULL, on extrait le premier de la liste;
  196. // retourne NULL si l'objet à extraire n'existe pas
  197. static Objet* extraireApres (Liste* li, Element* precedent) {
  198.   if (precedent == NULL) {
  199.     return extraireEnTeteDeListe (li);
  200.   } else {
  201.     Element* extrait = precedent->suivant;
  202.     if (extrait != NULL) {
  203.       precedent->suivant = extrait->suivant;
  204.       if (extrait == li->dernier) li->dernier = precedent;
  205.       li->nbElt--;
  206.     }
  207.     return extrait != NULL ? extrait->reference : NULL;
  208.   }
  209. }
  210. // fournir un pointeur sur l'élément courant de la liste li,
  211. // et se positionner sur le suivant qui devient le courant
  212. static Element* elementCourant (Liste* li) {
  213.   Element* ptc = li->courant;
  214.   if (li->courant != NULL) {
  215.     li->courant = li->courant->suivant;
  216.   }
  217.   return ptc;
  218. }
  219. #if 0
  220. static Element* ppremier (Liste* li) {
  221.   return li->premier;
  222. }
  223. //static Element* pdernier (Liste* li) {
  224. //  return li->dernier;
  225. //}
  226. Objet* pDernier (Liste* li) {
  227.   return li->dernier == NULL ? NULL : li->dernier->reference;
  228. }
  229. static Element* psuivant (Element* elt) {
  230.   return elt!=NULL ? elt->suivant : NULL;
  231. }
  232. #endif
  233. // LISTE ORDONNEE
  234. // objet1 et objet2 sont-ils en ordre ?
  235. static booleen enOrdre (Objet* objet1, Objet* objet2, booleen ordreCroissant,
  236.                  int (*comparer) (Objet*, Objet*)) {
  237.   booleen ordre = comparer (objet1, objet2) < 0;
  238.   if (!ordreCroissant) ordre = !ordre;
  239.   return ordre;
  240. }
  241. // la fonction comparer est passée en paramètre
  242. // et dépend du type de l'objet inséré dans la liste
  243. void insererEnOrdre (Liste* li, Objet* objet) {
  244.   if (listeVide (li) ) {   // liste vide
  245.     insererEnTeteDeListe (li, objet);
  246.     //printf ("insertion dans liste vide\n" );
  247.   } else {
  248.     Element* ptc = li->premier;
  249.     if ( enOrdre (objet, ptc->reference, li->type==1, li->comparer) ) {
  250.       // insertion avant le premier élément
  251.       //printf ("insertion en tête de liste non vide\n" );
  252.       insererEnTeteDeListe (li, objet);
  253.     } else {    // insertion en milieu ou fin de liste
  254.       //printf ("insertion en milieu ou fin de liste non vide\n" );
  255.       booleen  trouve = faux;
  256.       Element* prec   = NULL;
  257.       while (ptc != NULL && !trouve) {
  258.         prec   = ptc;
  259.         ptc    = ptc->suivant;
  260.         if (ptc!=NULL) trouve = enOrdre (objet, ptc->reference, li->type==1, li->comparer);
  261.       }
  262.       // insertion en milieu de liste ou fin de liste
  263.       insererApres (li, prec, objet);
  264.     }
  265.   }
  266. }


********************************************
 
2.  le module de l application qui utilise le module LISTE SIMPLE est de type personne ( " mdtypes.h " et  "  mdtypes.cpp " ) le voici ci dessous
 

Code :
  1. //mdtypes.h
  2. #ifndef MDTYPES_H
  3. #define MDTYPES_H
  4. typedef char ch15[16];
  5. typedef void Objet;
  6. //Une personne
  7. typedef struct
  8. {
  9.     ch15 nom;
  10.     ch15 prenom;
  11. }Personne;
  12. Personne* creerPersonne (char* nom, char* prenom);
  13. Personne* creerPersonne();
  14. void ecrirePersonne (Objet* objet);
  15. char* toStringPersonne (Objet* objet);
  16. int comparerPersonne(Objet* objet1, Objet* objet2);
  17. #endif // MDTYPES_H_INCLUDED


 
 
 
 

Code :
  1. /* mdtypes.cpp différents types */
  2. #include <stdio.h>
  3. #include <string.h>      //strcpy, strcmp
  4. #include "mdtypes.h"
  5. //Constructeur de Personne
  6. Personne* creerPersonne (char* nom, char* prenom)
  7. {
  8.     Personne* p = newPersonne();
  9.     strcpy(p -> nom, nom);
  10.     strcpy(p -> prenom, prenom);
  11.     return p;
  12. }
  13. //Lecture du nom et prenom
  14. Personne* creerPersonne()
  15. {
  16.     printf("Nom de la personne a cree?\n" );
  17.     ch15 nom; scanf("%s", nom);
  18.     printf("prenom de la personne a creer?\n" );
  19.     ch15 prenom; scanf("%s", prenom);
  20.     Personne* nouveau = creerPersonne(nom, prenom);
  21.     return nouveau;
  22. }
  23. //Ecrire les caracteristique d une Personne
  24. void ecrirePersonne(Personne* p)
  25. {
  26.     printf("%s %s\n", p -> nom, p -> prenom);
  27. }
  28. //fournir les caracteristiques d une personne
  29. char* toStringPersonne(Personne* p)
  30. {
  31.     char* message = (char*) malloc(30);    //test à faire
  32.     sprintf(message,"%s %s", p ->nom, p -> prenom);
  33.     return message;
  34. }
  35. //Comparer deux personnes
  36. //fournir <0 si p1 < p2; 0 si p1 =P2; >0 sinon
  37. int comparerPersonne(Personne* p1, Personne* p2)
  38. {
  39.     return strcmp (p1 -> nom, p2 -> nom);
  40. }
  41. void ecrirePersonne(Objet* objet)
  42. {
  43.     ecrirePersonne((personne*)objet);
  44. }
  45. char* toStringPersonne(Objet* objet)
  46. {
  47.     return toStringPersonne((Personne*)objet);
  48. }
  49. int comparerPersonne(Objet* objet1, Objet* objet2)
  50. {
  51.      return  comparerPersonne((Personne*)objet1, (Personne*)objet2);
  52. }


 
****************************************
 
3 voici le fichier  principal main.c
 
 

Code :
  1. #include <stdio.h>
  2. #include "liste.h"
  3. #include "mdtypes.h"
  4. #if 1
  5. int menu () {
  6.   printf ("\n\nGESTION D'UNE LISTE DE PERSONNES\n\n" );
  7.   printf ("0 - Fin\n" );
  8.   printf ("1 - Insertion   en tête de liste\n" );
  9.   printf ("2 - Insertion   en fin  de liste\n" );
  10.   printf ("3 - Retrait     en tête de liste\n" );
  11.   printf ("4 - Retrait     en fin  de liste\n" );
  12.   printf ("5 - Retrait     d'un élément à partir de son nom\n" );
  13.   printf ("6 - Parcours    de la liste\n" );
  14.   printf ("7 - Recherche   d'un élément à partir de son nom\n" );
  15.   printf ("8 - Insertion   ordonnée à partir d'un fichier\n" );
  16.   printf ("9 - Destruction de la liste\n" );
  17.   printf ("\n" );
  18.   printf ("Votre choix ? " );
  19.   int cod; scanf ("%d", &cod); getchar();
  20.   printf ("\n" );
  21.   return cod;
  22. }
  23. void main () {
  24.   Liste* lp = creerListe(0, toStringPersonne, comparerPersonne);
  25.   booleen fini = faux;
  26.   while (!fini) {
  27.     switch (menu() ) {
  28.     case 0:
  29.       fini = vrai;
  30.       break;
  31.     case 1 : {
  32.       Personne* nouveau = creerPersonne();
  33.       insererEnTeteDeListe (lp, nouveau);
  34.       } break;
  35.     case 2 : {
  36.       Personne* nouveau = creerPersonne();
  37.       insererEnFinDeListe (lp, nouveau);
  38.       } break;
  39.     case 3 : {
  40.       Personne* extrait = (Personne*) extraireEnTeteDeListe (lp);
  41.       if (extrait != NULL) {
  42.         printf ("Elément %s %s extrait en tête de liste",
  43.                 extrait->nom, extrait->prenom);
  44.       } else {
  45.         printf ("Liste vide" );
  46.       }
  47.       } break;
  48.     case 4 : {
  49.       Personne* extrait = (Personne*) extraireEnFinDeListe (lp);
  50.       if (extrait != NULL) {
  51.         printf ("Elément %s %s extrait en fin de liste",
  52.                 extrait->nom, extrait->prenom);
  53.       } else {
  54.         printf ("Liste vide" );
  55.       }
  56.       } break;
  57.     case 5 : {
  58.       printf ("Nom de la personne à extraire ? " );
  59.       ch15 nom; scanf ("%s", nom);
  60.       Personne* cherche = creerPersonne (nom, "?" );
  61.       Personne* pp      = (Personne*) chercherUnObjet (lp, cherche);
  62.       booleen extrait   = extraireUnObjet (lp, pp);
  63.       if (extrait) {
  64.           printf ("Elément %s %s extrait de la liste",
  65.             pp->nom, pp->prenom);
  66.       }
  67.       } break;
  68.     case 6:
  69.       listerListe (lp);
  70.       break;
  71.     case 7 : {
  72.       printf ("Nom de la personne recherchée ? " );
  73.       ch15 nom; scanf ("%s", nom);
  74.       Personne* cherche = creerPersonne (nom, "?" );
  75.       Personne* pp      = (Personne*) chercherUnObjet (lp, cherche);
  76.       if (pp != NULL) {
  77.         printf ("%s %s trouvée dans la liste\n", pp->nom, pp->prenom);
  78.       } else {
  79.         printf ("%s inconnue dans la liste\n", nom);
  80.       }
  81.       } break;
  82.     case 8:{
  83.       printf ("1 - Insertion en ordre croissant\n" );
  84.       printf ("2 - Insertion en ordre décroissant\n" );
  85.       printf ("\nVotre choix ? " );
  86.       int cd; scanf ("%d", &cd);
  87.       FILE* fe = fopen ("noms.txt", "r" );
  88.       if (fe==NULL) {
  89.         printf ("Erreur ouverture de noms.txt\n" );
  90.       } else {
  91.         lp = creerListe(cd, toStringPersonne, comparerPersonne);
  92.         while ( !feof (fe) ) {
  93.           ch15 nom; ch15 prenom;
  94.           fscanf (fe, "%15s%15s", nom, prenom);
  95.           Personne* nouveau = creerPersonne (nom, prenom);
  96.           insererEnOrdre (lp, nouveau);
  97.         }
  98.         fclose (fe);
  99.         listerListe (lp);
  100.       }
  101.       } break;
  102.     case 9:
  103.       detruireListe (lp);
  104.       break;
  105.     } // switch
  106.   } // while
  107. }
  108. #else
  109. void main () {
  110.   // liste non ordonnée d'entiers
  111.   Liste* le = creerListe ();  // liste d'entiers
  112.   initListe (le, NONORDONNE, toStringEntier, comparerEntier);
  113.   int i1 = 10;
  114.   insererEnTeteDeListe (le, &i1);
  115.   int i2 = 5;
  116.   insererEnTeteDeListe (le, &i2);
  117.   int i3 = 15;
  118.   insererEnTeteDeListe (le, &i3);
  119.   listerListe (le);
  120.   //listerListe (le, ecrireEntier);
  121.   // liste non ordonnée de personnes
  122.   ListePersonnes*  lp = creerListe();
  123.   initListe (lp, NONORDONNE, toStringPersonne, comparerPersonne);
  124.   Personne* p1 = creerPersonne ("Dupont", "Jacques" );
  125.   insererEnTeteDeListe (lp, p1);
  126.   Personne* p2 = creerPersonne ("Aubry",  "Michel" );
  127.   insererEnTeteDeListe (lp, p2);
  128.   Personne* p3 = creerPersonne ("Zorro", "Jacques" );
  129.   insererEnTeteDeListe (lp, p3);
  130.   listerListe (lp);
  131.   // liste ordonnée croissante d'entiers
  132.   Liste* loe = creerListe();
  133.   initListe (loe, CROISSANT, toStringEntier, comparerEntier);
  134.   int i4 = 10;
  135.   insererEnOrdre (loe, &i4);
  136.   int i5 = 5;
  137.   insererEnOrdre (loe, &i5);
  138.   int i6 = 15;
  139.   insererEnOrdre (loe, &i6);
  140.   printf ("\n\nListe ordonnée croissante d'entiers\n" );
  141.   listerListe (loe);
  142.   // liste ordonnée décroissante de personnes
  143.   Liste* lop = creerListe();
  144.   initListe (lop, DECROISSANT, toStringPersonne, comparerPersonne);
  145.   Personne* p4 = creerPersonne ("Dupont", "Jacques" );
  146.   insererEnOrdre (lop, p4);
  147.   Personne* p5 = creerPersonne ("Aubry",  "Michel" );
  148.   insererEnOrdre (lop, p5);
  149.   Personne* p6 = creerPersonne ("Zorro", "Jacques" );
  150.   insererEnOrdre (lop, p6);
  151.   printf ("\n\nListe ordonnée décroissante de personnes\n" );
  152.   listerListe (lop);
  153. }
  154. #endif


 
4. apres compilation avec codeBlocks  il a des messages d erreur  comme conflicting type for initListe
 
 
merci pour votre aide (j écris le code en language c)

Message cité 1 fois
Message édité par gilou le 22-03-2012 à 15:58:29
mood
Publicité
Posté le 21-03-2012 à 04:31:15  profilanswer
 

n°2132524
breizhbugs
Posté le 22-03-2012 à 15:11:15  profilanswer
 

Bonjour,
- Utilise les balises 'code' (bouton "C/C++" ) pour poster ton code.
- Donne le contenu exact du message d'erreur (avec nom de fichier + numéro de ligne).


---------------
Seul Google le sait...
n°2132525
gilou
Modérateur
Modzilla
Posté le 22-03-2012 à 15:57:38  profilanswer
 

Citation :

ListePersonnes*  lp = creerListe();


au lieu de

Citation :

Liste*  lp = creerListe();


non?
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
n°2132755
Sve@r
Posté le 24-03-2012 à 16:18:03  profilanswer
 

mylo07 a écrit :

...(j écris le code en language c)


Mouais. Etant donné qu'on est dans le forum consacré au langage C, c'est en effet une bonne idée...

n°2133117
__werz
Posté le 27-03-2012 à 02:12:43  profilanswer
 

conflicting type for initListe: en C, tu ne peux pas déclarer deux fonctions avec le même nom (en tout cas pas dans le même espace de nommage), or ta fonction initList est déclarée plusieurs fois avec des prototypes différents, de même que creerListe et listerListe. Supprime les doublons (en mettant à jour les endroits où ils sont utilisés) et ça ira déjà un peu mieux.
 
Je note d'ailleurs que tu as écrit beaucoup de code mais que tu n'as vraisemblablement pas essayé de le compiler au fur et à mesure, essaye toujours d'avancer petit à petit en ajoutant une fonctionnalité à la fois, tu gagnera du temps.
 
Bon courage.


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  comment utiliser deux module liste simple avec une autre application

 

Sujets relatifs
[PHP+SQL] Cherche un petit coup de main pour une application simpleListe déroulante mysql (affichage + insertion)
Utiliser Java dans le Framework .NETRemplire formulaire d'un application
Coordonnées fenêtre application externe[Débutant] Module Turtle et Tkinter
ECHEC - L'application pour le chemin de contexte /OpenClinica nerreur d'allocation mémoire dans une application console C++
pb liste chainée et lecture de fichier C 
Plus de sujets relatifs à : comment utiliser deux module liste simple avec une autre application


Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR