comment utiliser deux module liste simple avec une autre application

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : comment utiliser deux module liste simple avec une autre application

mylo07

Etudiant

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 :

// liste.h
#ifndef LISTE_H
#define LISTE_H
#ifdef WINDOWS
#define DllExport __declspec( dllexport ) // for windows
#else
#define DllExport // Linux
#endif
#define faux 0
#define vrai 1
typedef int booleen;
typedef void Objet;
#define NONORDONNE 0
#define CROISSANT 1
#define DECROISSANT 2
// un élément de la liste
typedef struct element {
Objet* reference; // référence un objet (de l'application)
struct element* suivant; // élément suivant de la liste
} Element;
// le type Liste
typedef struct {
Element* premier; // premier élément de la liste
Element* dernier; // dernier élément de la liste
Element* courant; // élément en cours de traitement (parcours de liste)
int nbElt; // nombre d'éléments dans la liste
int type; // 0:simple, 1:croissant, 2:décroissant
char* (*toString) (Objet*);
int (*comparer) (Objet*, Objet*);
} Liste;
DllExport void initListe (Liste* li, int type, char* (*toString) (Objet*),
int (*comparer) (Objet*, Objet*) );
DllExport void initListe (Liste* li);
DllExport Liste* creerListe (int type, char* (*toString) (Objet*),
int (*comparer) (Objet*, Objet*) );
DllExport Liste* creerListe (int type);
DllExport Liste* creerListe ();
DllExport booleen listeVide (Liste* li);
DllExport int nbElement (Liste* li);
DllExport void insererEnTeteDeListe (Liste* li, Objet* objet);
DllExport void insererEnFinDeListe (Liste* li, Objet* objet);
// parcours de liste
DllExport void ouvrirListe (Liste* li);
DllExport booleen finListe (Liste* li);
DllExport Objet* objetCourant (Liste* li);
DllExport void listerListe (Liste* li);
DllExport void listerListe (Liste* li, void (*f) (Objet*));
DllExport Objet* chercherUnObjet (Liste* li, Objet* objetCherche);
DllExport Objet* extraireEnTeteDeListe (Liste* li);
DllExport Objet* extraireEnFinDeListe (Liste* li);
DllExport booleen extraireUnObjet (Liste* li, Objet* objet);
DllExport void detruireListe (Liste* li);
DllExport void recopierListe (Liste* l1, Liste* l2);
//Element* pPremier (Liste* li);
//Element* pDernier (Liste* li);
//Objet* pDernier (Liste* li);
//Element* pSuivant (Element* elt);
// LISTE ORDONNEE
DllExport void insererEnOrdre (Liste* li, Objet* objet);
#endif

Code :

/* liste.cpp
Ce module de gestion de listes est très général
et indépendant des applications.
Il gère des listes simples d'éléments avec tête de liste */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "liste.h"
// fonctions locales au module
static Element* creerElement ();
static void insererApres (Liste* li, Element* precedent, Objet* objet);
static Objet* extraireApres (Liste* li, Element* precedent);
static Element* elementCourant (Liste* li);
// comparer deux chaînes de caractères
// fournit <0 si ch1 < ch2; 0 si ch1=ch2; >0 sinon
static int comparerCar (Objet* objet1, Objet* objet2) {
return strcmp ((char*)objet1,(char*)objet2);
}
static char* toChar (Objet* objet) {
return (char*) objet;
}
// initialiser la liste pointée par li (cas général)
void initListe (Liste* li, int type, char* (*toString) (Objet*),
int (*comparer) (Objet*, Objet*)) {
li->premier = NULL;
li->dernier = NULL;
li->courant = NULL;
li->nbElt = 0;
li->type = type;
li->toString = toString;
li->comparer = comparer;
}
// initialisation par défaut
void initListe (Liste* li) {
initListe (li, NONORDONNE, toChar, comparerCar);
}
Liste* creerListe (int type, char* (*toString) (Objet*),
int (*comparer) (Objet*, Objet*)) {
Liste* li = new Liste();
initListe (li, type, toString, comparer);
return li;
}
Liste* creerListe (int type) {
return creerListe (type, toChar, comparerCar);
}
Liste* creerListe () {
return creerListe (NONORDONNE, toChar, comparerCar);
}
// la liste est-elle vide ?
booleen listeVide (Liste* li) {
return li->nbElt == 0;
}
// fournir le nombre d'éléments dans la liste
int nbElement (Liste* li) {
return li->nbElt;
}
// INSERER UN OBJET DANS UNE LISTE
// insérer objet en tête de la liste li
// l'objet est repéré par le champ reference de l'élément de la liste
void insererEnTeteDeListe (Liste* li, Objet* objet) {
Element* nouveau = creerElement();
nouveau->reference = objet;
nouveau->suivant = li->premier;
li->premier = nouveau;
if (li->dernier == NULL) li->dernier = nouveau;
li->nbElt++;
}
// insérer un objet en fin de la liste li
void insererEnFinDeListe (Liste* li, Objet* objet) {
insererApres (li, li->dernier, objet);
}
// PARCOURS DE LISTE
// se positionner sur le premier élément de la liste li
void ouvrirListe (Liste* li) {
li->courant = li->premier;
}
// a-t-on atteint la fin de la liste li ?
booleen finListe (Liste* li) {
return li->courant==NULL;
}
// fournir un pointeur sur l'objet courant de la liste li,
// et se positionner sur le suivant qui devient le courant
Objet* objetCourant (Liste* li) {
Element* ptc = elementCourant (li);
return ptc==NULL ? NULL : ptc->reference;
}
void listerListe (Liste* li) {
ouvrirListe (li);
while (!finListe (li)) {
Objet* objet = objetCourant (li);
printf ("%s\n", li->toString (objet));
}
}
// lister la liste li;
// f est une fonction passée en paramètre
// et ayant un pointeur de type quelconque.
// Ceci s'apparente aux méthodes virtuelles en PO.
void listerListe (Liste* li, void (*f) (Objet*)) {
ouvrirListe (li);
while (!finListe (li)) {
Objet* objet = objetCourant (li);
f (objet); // appliquer la fonction f() à objet
}
}
// fournir un pointeur sur l'objet "objetCherche" de la liste li;
// NULL si l'objet n'existe pas
Objet* chercherUnObjet (Liste* li, Objet* objetCherche) {
booleen trouve = faux;
Objet* objet; // pointeur courant
ouvrirListe (li);
while (!finListe (li) && !trouve) {
objet = objetCourant (li);
trouve = li->comparer (objetCherche, objet) == 0;
}
return trouve ? objet : NULL;
}
// EXTRAIRE UN OBJET D'UNE LISTE
// extraire l'objet en tête de la liste li
Objet* extraireEnTeteDeListe (Liste* li) {
Element* extrait = li->premier;
if (!listeVide(li)) {
li->premier = li->premier->suivant;
if (li->premier==NULL) li->dernier=NULL; // Liste devenue vide
li->nbElt--;
}
return extrait != NULL ? extrait->reference : NULL;
}
// extraire l'objet en fin de la liste li
Objet* extraireEnFinDeListe (Liste* li) {
Objet* extrait;
if (listeVide(li)) {
extrait = NULL;
} else if (li->premier == li->dernier) { // un seul élément
extrait = extraireEnTeteDeListe (li);
} else {
Element* ptc = li->premier;
while (ptc->suivant != li->dernier) ptc = ptc->suivant;
extrait = extraireApres (li, ptc);
}
return extrait;
}
// extraire de la liste li, l'objet pointé par objet
booleen extraireUnObjet (Liste* li, Objet* objet) {
Element* precedent = NULL;
Element* ptc = NULL;
// repère l'élement précédent
booleen trouve = faux;
ouvrirListe (li);
while (!finListe (li) && !trouve) {
precedent = ptc;
ptc = elementCourant (li);
trouve = (ptc->reference == objet) ? vrai : faux;
}
if (!trouve) return faux;
Objet* extrait = extraireApres (li, precedent);
return vrai;
}
// parcours de liste avec destruction de chaque élément
void detruireListe (Liste* li) {
ouvrirListe (li);
while (!finListe (li)) {
Element* ptc = elementCourant (li);
//free (ptc->reference); // si on veut détruire les objets de la liste
free (ptc);
}
initListe (li);
}
// recopie l2 dans l1 et initialise l2
void recopierListe (Liste* l1, Liste* l2) {
detruireListe (l1);
*l1 = *l2; // on recopie les têtes de listes
initListe (l2);
}
// FONCTIONS LOCALES AU MODULE
// créer un élément de liste
static Element* creerElement () {
//return (Element*) malloc (sizeof (Element));
return new Element();
}
// insérer dans la liste li, objet après precedent
// si precedent est NULL, insérer en tête de liste
static void insererApres (Liste* li, Element* precedent, Objet* objet) {
if (precedent == NULL) {
insererEnTeteDeListe (li, objet);
} else {
Element* nouveau = creerElement();
nouveau->reference = objet;
nouveau->suivant = precedent->suivant;
precedent->suivant = nouveau;
if (precedent == li->dernier) li->dernier = nouveau;
li->nbElt++;
}
}
// Extraire l'objet de li se trouvant après l'élément precedent;
// si precedent vaut NULL, on extrait le premier de la liste;
// retourne NULL si l'objet à extraire n'existe pas
static Objet* extraireApres (Liste* li, Element* precedent) {
if (precedent == NULL) {
return extraireEnTeteDeListe (li);
} else {
Element* extrait = precedent->suivant;
if (extrait != NULL) {
precedent->suivant = extrait->suivant;
if (extrait == li->dernier) li->dernier = precedent;
li->nbElt--;
}
return extrait != NULL ? extrait->reference : NULL;
}
}
// fournir un pointeur sur l'élément courant de la liste li,
// et se positionner sur le suivant qui devient le courant
static Element* elementCourant (Liste* li) {
Element* ptc = li->courant;
if (li->courant != NULL) {
li->courant = li->courant->suivant;
}
return ptc;
}
#if 0
static Element* ppremier (Liste* li) {
return li->premier;
}
//static Element* pdernier (Liste* li) {
// return li->dernier;
//}
Objet* pDernier (Liste* li) {
return li->dernier == NULL ? NULL : li->dernier->reference;
}
static Element* psuivant (Element* elt) {
return elt!=NULL ? elt->suivant : NULL;
}
#endif
// LISTE ORDONNEE
// objet1 et objet2 sont-ils en ordre ?
static booleen enOrdre (Objet* objet1, Objet* objet2, booleen ordreCroissant,
int (*comparer) (Objet*, Objet*)) {
booleen ordre = comparer (objet1, objet2) < 0;
if (!ordreCroissant) ordre = !ordre;
return ordre;
}
// la fonction comparer est passée en paramètre
// et dépend du type de l'objet inséré dans la liste
void insererEnOrdre (Liste* li, Objet* objet) {
if (listeVide (li) ) { // liste vide
insererEnTeteDeListe (li, objet);
//printf ("insertion dans liste vide\n" );
} else {
Element* ptc = li->premier;
if ( enOrdre (objet, ptc->reference, li->type==1, li->comparer) ) {
// insertion avant le premier élément
//printf ("insertion en tête de liste non vide\n" );
insererEnTeteDeListe (li, objet);
} else { // insertion en milieu ou fin de liste
//printf ("insertion en milieu ou fin de liste non vide\n" );
booleen trouve = faux;
Element* prec = NULL;
while (ptc != NULL && !trouve) {
prec = ptc;
ptc = ptc->suivant;
if (ptc!=NULL) trouve = enOrdre (objet, ptc->reference, li->type==1, li->comparer);
}
// insertion en milieu de liste ou fin de liste
insererApres (li, prec, objet);
}
}
}

********************************************

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 :

//mdtypes.h
#ifndef MDTYPES_H
#define MDTYPES_H
typedef char ch15[16];
typedef void Objet;
//Une personne
typedef struct
{
ch15 nom;
ch15 prenom;
}Personne;
Personne* creerPersonne (char* nom, char* prenom);
Personne* creerPersonne();
void ecrirePersonne (Objet* objet);
char* toStringPersonne (Objet* objet);
int comparerPersonne(Objet* objet1, Objet* objet2);
#endif // MDTYPES_H_INCLUDED

Code :

/* mdtypes.cpp différents types */
#include <stdio.h>
#include <string.h> //strcpy, strcmp
#include "mdtypes.h"
//Constructeur de Personne
Personne* creerPersonne (char* nom, char* prenom)
{
Personne* p = newPersonne();
strcpy(p -> nom, nom);
strcpy(p -> prenom, prenom);
return p;
}
//Lecture du nom et prenom
Personne* creerPersonne()
{
printf("Nom de la personne a cree?\n" );
ch15 nom; scanf("%s", nom);
printf("prenom de la personne a creer?\n" );
ch15 prenom; scanf("%s", prenom);
Personne* nouveau = creerPersonne(nom, prenom);
return nouveau;
}
//Ecrire les caracteristique d une Personne
void ecrirePersonne(Personne* p)
{
printf("%s %s\n", p -> nom, p -> prenom);
}
//fournir les caracteristiques d une personne
char* toStringPersonne(Personne* p)
{
char* message = (char*) malloc(30); //test à faire
sprintf(message,"%s %s", p ->nom, p -> prenom);
return message;
}
//Comparer deux personnes
//fournir <0 si p1 < p2; 0 si p1 =P2; >0 sinon
int comparerPersonne(Personne* p1, Personne* p2)
{
return strcmp (p1 -> nom, p2 -> nom);
}
void ecrirePersonne(Objet* objet)
{
ecrirePersonne((personne*)objet);
}
char* toStringPersonne(Objet* objet)
{
return toStringPersonne((Personne*)objet);
}
int comparerPersonne(Objet* objet1, Objet* objet2)
{
return comparerPersonne((Personne*)objet1, (Personne*)objet2);
}

****************************************

3 voici le fichier principal main.c

Code :

#include <stdio.h>
#include "liste.h"
#include "mdtypes.h"
#if 1
int menu () {
printf ("\n\nGESTION D'UNE LISTE DE PERSONNES\n\n" );
printf ("0 - Fin\n" );
printf ("1 - Insertion en tête de liste\n" );
printf ("2 - Insertion en fin de liste\n" );
printf ("3 - Retrait en tête de liste\n" );
printf ("4 - Retrait en fin de liste\n" );
printf ("5 - Retrait d'un élément à partir de son nom\n" );
printf ("6 - Parcours de la liste\n" );
printf ("7 - Recherche d'un élément à partir de son nom\n" );
printf ("8 - Insertion ordonnée à partir d'un fichier\n" );
printf ("9 - Destruction de la liste\n" );
printf ("\n" );
printf ("Votre choix ? " );
int cod; scanf ("%d", &cod); getchar();
printf ("\n" );
return cod;
}
void main () {
Liste* lp = creerListe(0, toStringPersonne, comparerPersonne);
booleen fini = faux;
while (!fini) {
switch (menu() ) {
case 0:
fini = vrai;
break;
case 1 : {
Personne* nouveau = creerPersonne();
insererEnTeteDeListe (lp, nouveau);
} break;
case 2 : {
Personne* nouveau = creerPersonne();
insererEnFinDeListe (lp, nouveau);
} break;
case 3 : {
Personne* extrait = (Personne*) extraireEnTeteDeListe (lp);
if (extrait != NULL) {
printf ("Elément %s %s extrait en tête de liste",
extrait->nom, extrait->prenom);
} else {
printf ("Liste vide" );
}
} break;
case 4 : {
Personne* extrait = (Personne*) extraireEnFinDeListe (lp);
if (extrait != NULL) {
printf ("Elément %s %s extrait en fin de liste",
extrait->nom, extrait->prenom);
} else {
printf ("Liste vide" );
}
} break;
case 5 : {
printf ("Nom de la personne à extraire ? " );
ch15 nom; scanf ("%s", nom);
Personne* cherche = creerPersonne (nom, "?" );
Personne* pp = (Personne*) chercherUnObjet (lp, cherche);
booleen extrait = extraireUnObjet (lp, pp);
if (extrait) {
printf ("Elément %s %s extrait de la liste",
pp->nom, pp->prenom);
}
} break;
case 6:
listerListe (lp);
break;
case 7 : {
printf ("Nom de la personne recherchée ? " );
ch15 nom; scanf ("%s", nom);
Personne* cherche = creerPersonne (nom, "?" );
Personne* pp = (Personne*) chercherUnObjet (lp, cherche);
if (pp != NULL) {
printf ("%s %s trouvée dans la liste\n", pp->nom, pp->prenom);
} else {
printf ("%s inconnue dans la liste\n", nom);
}
} break;
case 8:{
printf ("1 - Insertion en ordre croissant\n" );
printf ("2 - Insertion en ordre décroissant\n" );
printf ("\nVotre choix ? " );
int cd; scanf ("%d", &cd);
FILE* fe = fopen ("noms.txt", "r" );
if (fe==NULL) {
printf ("Erreur ouverture de noms.txt\n" );
} else {
lp = creerListe(cd, toStringPersonne, comparerPersonne);
while ( !feof (fe) ) {
ch15 nom; ch15 prenom;
fscanf (fe, "%15s%15s", nom, prenom);
Personne* nouveau = creerPersonne (nom, prenom);
insererEnOrdre (lp, nouveau);
}
fclose (fe);
listerListe (lp);
}
} break;
case 9:
detruireListe (lp);
break;
} // switch
} // while
}
#else
void main () {
// liste non ordonnée d'entiers
Liste* le = creerListe (); // liste d'entiers
initListe (le, NONORDONNE, toStringEntier, comparerEntier);
int i1 = 10;
insererEnTeteDeListe (le, &i1);
int i2 = 5;
insererEnTeteDeListe (le, &i2);
int i3 = 15;
insererEnTeteDeListe (le, &i3);
listerListe (le);
//listerListe (le, ecrireEntier);
// liste non ordonnée de personnes
ListePersonnes* lp = creerListe();
initListe (lp, NONORDONNE, toStringPersonne, comparerPersonne);
Personne* p1 = creerPersonne ("Dupont", "Jacques" );
insererEnTeteDeListe (lp, p1);
Personne* p2 = creerPersonne ("Aubry", "Michel" );
insererEnTeteDeListe (lp, p2);
Personne* p3 = creerPersonne ("Zorro", "Jacques" );
insererEnTeteDeListe (lp, p3);
listerListe (lp);
// liste ordonnée croissante d'entiers
Liste* loe = creerListe();
initListe (loe, CROISSANT, toStringEntier, comparerEntier);
int i4 = 10;
insererEnOrdre (loe, &i4);
int i5 = 5;
insererEnOrdre (loe, &i5);
int i6 = 15;
insererEnOrdre (loe, &i6);
printf ("\n\nListe ordonnée croissante d'entiers\n" );
listerListe (loe);
// liste ordonnée décroissante de personnes
Liste* lop = creerListe();
initListe (lop, DECROISSANT, toStringPersonne, comparerPersonne);
Personne* p4 = creerPersonne ("Dupont", "Jacques" );
insererEnOrdre (lop, p4);
Personne* p5 = creerPersonne ("Aubry", "Michel" );
insererEnOrdre (lop, p5);
Personne* p6 = creerPersonne ("Zorro", "Jacques" );
insererEnOrdre (lop, p6);
printf ("\n\nListe ordonnée décroissante de personnes\n" );
listerListe (lop);
}
#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

Publicité

breizhbugs

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

gilou

Modérateur
Modzilla

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

Sve@r

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

__werz

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.

FORUM HardWare.fr

Programmation

comment utiliser deux module liste simple avec une autre application

Sujets relatifs
[PHP+SQL] Cherche un petit coup de main pour une application simple	Liste déroulante mysql (affichage + insertion)
Utiliser Java dans le Framework .NET	Remplire 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 n	erreur 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

Page générée en 0.258 secondes