Les listes
2.4 EXEMPLES D’APPLICATION
2.4.2 Liste de personnes
// fournir les caractéristiques 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);
}
2.4.2 Liste de personnes
Il s’agit de gérer une liste de personnes. On suppose qu’il y a de nombreux départs et arrivées de personnes. L’information étant volatile, l’utilisation d’une liste permet de résoudre le problème simplement sans réservation inutile d’espace mémoire.
L’inclusion du fichier d’en-tête liste.h fournit à l’utilisateur, la déclaration du type Liste et les prototypes des fonctions. L’inclusion du fichier "mdtypes.h" définit le type Personne et les fonctions correspondantes.
/* pplistpers.cpp programme principal de liste de personnes Utilisation du module de gestion de listes;
Application à la gestion d'une liste de personnes */
#include <stdio.h>
#include "liste.h"
#include "mdtypes.h"
typedef Liste ListePersonnes; // un équivalent plus mnémonique
Le menu et le programme principal suivants permettent l’insertion d’une nouvelle personne en tête ou en fin de liste, l’extraction de la personne en tête ou en fin de liste ou d’une personne dont on fournit le nom, l’écriture de la liste des personnes, la recherche d’une personne à partir de son nom et la destruction de la liste. On peut également initialiser une liste ordonnée à partir d’un fichier dont on fournit le nom ; l’insertion peut se faire en ordre croissant ou décroissant.
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");
03Chap_02 Page 52 Samedi, 17. janvier 2004 10:36 10
2.4 • Exemples d’application 53
© Dunod – La photocopie non autorisée est un délit.
printf ("2 - Insertion en fin de liste\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);
printf ("\n");
return cod;
}
void main () {
Liste* lp = creerListe (0, toStringPersonne, comparerPersonne);
booleen fini = faux;
insererEnTeteDeListe (lp, nouveau);
} break;
case 2 : {
Personne* nouveau = creerPersonne();
insererEnFinDeListe (lp, nouveau);
} break;
case 3 : {
Personne* extrait = (Personne*) extraireEnTeteDeListe (lp);
if (extrait != NULL) {
Personne* extrait = (Personne*) extraireEnFinDeListe (lp);
if (extrait != NULL) {
03Chap_02 Page 53 Samedi, 17. janvier 2004 10:36 10
54 2 • Les listes
lp = creerListe (cd, toStringPersonne, comparerPersonne);
while ( !feof (fe) ) {
Exemple d’exécution, le fichier noms.dat contient les informations suivantes :
Duval Albert Dupont Julien Dupond Michèle Duvallon Jacqueline Duroc René 03Chap_02 Page 54 Samedi, 17. janvier 2004 10:36 10
2.4 • Exemples d’application 55
© Dunod – La photocopie non autorisée est un délit.
GESTION D'UNE LISTE DE PERSONNES 0 - Fin
1 - Insertion en tête de liste 2 - Insertion en fin de liste 3 - Retrait en tête de liste 4 - Retrait en fin de liste
5 - Retrait d'un élément à partir de son nom 6 - Parcours de la liste
7 - Recherche d'un élément à partir de son nom 8 - Insertion ordonnée à partir d'un fichier 9 - Destruction de la liste
Votre choix ? 8
1 - Insertion en ordre croissant 2 - Insertion en ordre décroissant Votre choix ? 1
Dupond Michèle Dupont Julien Duroc René Duval Albert
Duvallon Jacqueline 2.4.3 Les polynômes
Il s’agit de mémoriser des polynômes d’une variable réelle et de réaliser des opéra-tions sur ces polynômes. Le nombre de monômes est variable, aussi une allocation dynamique d’espace mémoire s’impose. La gestion en liste facilite l’ajout ou la suppression de monômes pour un polynôme donné.
Les polynômes suivants : A = 3x5 + 2x3 + 1 B = 6x5 - 5x4 - 2x3 + 8 x2
peuvent être mémorisés comme indiqué sur la Figure 26.
coefficient exposant
Figure 25 Le type Monome.
03Chap_02 Page 55 Samedi, 17. janvier 2004 10:36 10
56 2 • Les listes
On crée un module polynome en définissant l’interface polynome.h du module (voir Figure 16, page 25). Le type Monome est une structure (un objet) contenant un coefficient réel et un exposant entier. Le type Polynome correspond au type Liste puisqu’on utilise une liste ordonnée pour mémoriser le polynôme. Les fonctions du module polynôme permettent de créer un monôme, d’insérer un monôme dans un polynôme, de lister un polynôme et de calculer la valeur d’un polynôme pour une valeur de x donnée.
2.4.3.a Le fichier d’en-tête des polynômes
Le fichier d’en-tête polynome.h décrit l’interface du module des polynômes.
// polynome.h
#ifndef POLYNOME_H
#define POLYNOME_H
#include "liste.h"
typedef struct { double coefficient;
int exposant;
} Monome;
typedef Liste Polynome;
Monome* creerMonome (double coefficient, int exposant);
Monome* creerMonome ();
Polynome* creerPolynome ();
void insererEnOrdre (Polynome* po, Monome* nouveau);
void listerPolynome (Polynome* po);
double valeurPolynome (Polynome* po, double x);
Monome* chercherUnMonome (Polynome* po, Monome* nouveau);
booleen extraireMonome (Polynome* po, Monome* cherche);
void detruirePolynome (Polynome* po);
#endif B
/
/ A
3 5 2 3 1 0
6 5 –5 4 –2 3 8 2
Figure 26 Mémorisation de polynômes sous forme de listes.
03Chap_02 Page 56 Samedi, 17. janvier 2004 10:36 10
2.4 • Exemples d’application 57
© Dunod – La photocopie non autorisée est un délit.
2.4.3.b Le module des polynômes
Le fichier polynome.cpp contient le corps des fonctions définies ci-dessus. listerPo-lynome(), valeurPolynome() sont des algorithmes de parcours de listes.
/* polynome.cpp
Utilisation du module de gestion des listes */
#include <stdio.h>
#include <stdlib.h> // exit
#include "polynome.h"
// LES MONOMES
Monome* creerMonome (double coefficient, int exposant) { Monome* nouveau = new Monome();
nouveau->coefficient = coefficient;
nouveau->exposant = exposant;
return nouveau;
}
// créer un monôme par lecture du coefficient et de l'exposant Monome* creerMonome () {
double coefficient;
int exposant;
printf ("Coefficient ? "); scanf ("%lf", &coefficient);
printf ("Puissance ? "); scanf ("%d", &exposant);
return creerMonome (coefficient, exposant);
}
// écrire un monôme : +3.00 x**5 par exemple static void ecrireMonome (Monome* monome) {
printf (" %+.2f x**%d ", monome->coefficient, monome->exposant);
}
// comparer deux monômes m1 et m2
static int comparerMonome (Monome* m1, Monome* m2) { if (m1->exposant < m2->exposant) {
return -1;
} else if (m1->exposant == m2->exposant) { return 0;
} else { return 1;
} }
// écrire un objet monôme, pour listerPolynoome() static void ecrireMonome (Objet* objet) {
ecrireMonome ( (Monome*) objet);
}
static int comparerMonome (Objet* objet1, Objet* objet2) { return comparerMonome ((Monome*)objet1, (Monome*)objet2);
}
Polynome* creerPolynome () {
return creerListe (DECROISSANT, NULL, comparerMonome);
}
void insererEnOrdre (Polynome* po, Monome* nouveau) {
// sans (Objet*), le compilateur considère un appel récursif insererEnOrdre (po, (Objet*) nouveau); // du module liste }
03Chap_02 Page 57 Samedi, 17. janvier 2004 10:36 10
58 2 • Les listes
// puissance nième d'un nombre réel x (n entier >=0) // voir en 1.2.5 page 10
static double puissance (double x, int n) { double resu;
// lister le polynôme po
void listerPolynome (Polynome* po) { listerListe (po, ecrireMonome);
}
// valeur du polynôme po pour un x donné
double valeurPolynome (Polynome* po, double x) { Liste* li = po;
resu += ptc->coefficient*puissance(x, ptc->exposant);
} }
return resu;
}
Monome* chercherUnMonome (Polynome* po, Monome* nouveau) { return (Monome*) chercherUnObjet (po, nouveau);
}
booleen extraireMonome (Polynome* po, Monome* objet) { return extraireUnObjet (po, objet);
}
void detruirePolynome (Polynome* po) { detruireListe (po);
}
2.4.3.c Le programme principal des polynômes
Le menu et le programme principal suivants permettent de définir un polynôme (une liste ordonnée), d’y insérer des monômes en ordre décroissant des exposants, de lister le polynôme, de calculer la valeur du polynôme pour une valeur donnée, de supprimer un monôme à partir de son exposant ou de détruire la liste du polynôme.
03Chap_02 Page 58 Samedi, 17. janvier 2004 10:36 10
2.4 • Exemples d’application 59
© Dunod – La photocopie non autorisée est un délit.
/* pppolynome.cpp programme principal des polynômes Utilisation du module de gestion des listes */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "polynome.h"
int menu () {
printf ("\n\nGESTION DE POLYNOMES\n\n");
printf ("0 - Fin\n");
printf ("1 - Insertion d'un monôme\n");
printf ("2 - Écriture du polynôme\n");
printf ("3 - Valeur du pôlynome pour un x donné\n");
printf ("4 - Retrait d'un monôme à partir de son exposant\n");
printf ("5 - Destruction de la liste\n");
printf ("\nVotre choix ? ");
int cod; scanf ("%d", &cod);
printf ("\n");
03Chap_02 Page 59 Samedi, 17. janvier 2004 10:36 10
60 2 • Les listes
}
} break;
case 5 :
detruirePolynome (po);
break;
} // switch } // while }
L’encadré suivant est un exemple d’exécution de pppolynome.cpp pour la créa-tion du polynôme ordonné suivant les puissances décroissantes : A (x) = 3x5 + 2x3 + 1, et pour le calcul de sa valeur pour x=2.
GESTION DE POLYNOMES 0 - Fin
1 - Insertion d'un monôme 2 - Écriture du polynôme
3 - Valeur du polynôme pour un x donné
4 - Retrait d'un monôme à partir de son exposant 5 - Destruction de la liste
Votre choix ? 3
A(x) = +3.00 x**5 +2.00 x**3 +1.00 x**0 Valeur de x ? 2
A (2.00) = 113.00
Exercice 7 - Polynômes d’une variable réelle (lecture, addition)
Compléter les fonctions du polynôme du § 2.4.3.A, en créant un nouveau fichier d’en-tête polynome2.h comme suit :
/* polynome2.h */
#include <stdio.h>
#include "polynome.h"
Polynome* lirePolynome (FILE* fe);
Polynome* addPolynome (Polynome* a, Polynome* b);
Polynome* sousPolynome (Polynome* a, Polynome* b);
Écrire les fonctions suivantes (fichier polynome2.cpp) :
• Polynome* lirePolynome (FILE* fe) ; qui crée un polynôme en lisant les coeffi-cients et les exposants du polynôme dans le fichier fe.
• Polynome* addPolynome (Polynome* a, Polynome* b) ; qui fournit le polynôme résultant de l’addition des polynômes a et b.
03Chap_02 Page 60 Samedi, 17. janvier 2004 10:36 10
2.4 • Exemples d’application 61
© Dunod – La photocopie non autorisée est un délit.
• Polynome* sousPolynome (Polynome* a, Polynome* b) ; qui fournit le polynôme résultant de la soustraction des polynômes a et b.
Écrire un programme de test de lirePolynome(), addPolynome() et sousPoly-nome().