comment utiliser deux module liste simple avec une autre application

comment utiliser deux module liste simple avec une autre application - C - Programmation

Marsh Posté le 21-03-2012 à 04:31:15    

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


********************************************
 
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
  3. #ifndef MDTYPES_H
  4. #define MDTYPES_H
  6. typedef char ch15[16];
  7. typedef void Objet;
  10. //Une personne
  13. typedef struct
  14. {
  15.     ch15 nom;
  16.     ch15 prenom;
  17. }Personne;
  20. Personne* creerPersonne (char* nom, char* prenom);
  21. Personne* creerPersonne();
  22. void ecrirePersonne (Objet* objet);
  23. char* toStringPersonne (Objet* objet);
  24. int comparerPersonne(Objet* objet1, Objet* objet2);
  26. #endif // MDTYPES_H_INCLUDED


 
 
 
 

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


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

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

Marsh Posté le 21-03-2012 à 04:31:15   

Reply

Marsh Posté le 22-03-2012 à 15:11:15    

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

Marsh Posté le 22-03-2012 à 15:57:38    

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é!  --
Reply

Marsh Posté le 24-03-2012 à 16:18:03    

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

Reply

Marsh Posté le 27-03-2012 à 02:12:43    

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.

Reply

Sujets relatifs:

Leave a Replay

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