1 Exemples Construction et implantation de types de données abstraits.

Slides:



Advertisements
Présentations similaires
Création d'un formulaire Cliquer ici Taper un nom Choisir POST.
Advertisements

GEF 243B Programmation informatique appliquée Listes chaînées I – Tableaux de structures §15.1 – 15.2.
GEF 243B Programmation informatique appliquée
POO par Jenny Benois-Pineau 25/03/2017.
Chap. 4 Recherche en Table
Cours n° 7 Standard Template Library II.
Le langage Z Pr ZEGOUR DJAMEL EDDINE
DTD Sylvain Salvati
1 UMLV 1. Introduction 2. Hachage ouvert 3. Hachage fermé 4. Implémentation des fonctions Méthodes de hachage.
(Classes prédéfinies – API Java)
1 Tableaux des objets C++ si on connaît le nombre dobjets nécessaires davance on peut utiliser des tableau dobjets dans les fonctions dusage class Personne.
Créer un diaporama avec Open Office Impress
C.
Structures et unions types énumérés Qu'est-ce qu'une structure
FLSI602 Génie Informatique et Réseaux
Leçon 3 : Héritage IUP 2 Génie Informatique
Systèmes d’exploitation
B.Shishedjiev - Informatique II1 Travaux dirigés 5 Les structures.
Cours n°3 Les formulaires
Enregistrement d’un document
Active Directory Windows 2003 Server
ALGORITHMES RECURSIFS
Cours 7 - Les pointeurs, l'allocation dynamique, les listes chaînées
La technologie au collège et le B2i
JavaBeans Réalise par: EL KHADRAOUY TARIK AOUTIL SAFOWAN.
RECURSIVITE ARBRES BINAIRES
8PRO100 Éléments de programmation Allocation dynamique de la mémoire.
TRAITEMENT DE STRUCTURES
Les fichiers et les chaînes de caractères
Définition d’un maillon de liste
IFT-2000: Structures de Données Listes chaînées Dominic Genest, 2009.
1 Exercice : longueur d’un mot est-elle paire ?  Test fonctionnel  Quel ensemble de valeur choisir / spécification  Test structurel  Soit le code d’un.
Etude de cas : buffer clavier
Les pointeurs Modes d’adressage de variables. Définition d’un pointeur. Opérateurs de base. Opérations élémentaires. Pointeurs et tableaux. Pointeurs et.
IFT-2000: Structures de données
IFT-2000: Structures de données Les graphes Dominic Genest, 2009.
IFT-10541A : Hiver 2003 Semaine 1 : Type de données abstrait.
Modèles d’implantation
Sixième cours Les chaînes de caractères et le passage de paramètres par référence Passage de paramètres par référence String.h.
1 PROTOTYPE PGC++ Vecteur_3D DÉFINITION. 2 class Vecteur_3D { private : float vx, vy, vz, vw; // Représentation en coordonnées homogènes. public : Vecteur_3D();
Un langage de programmation hybride
Contrôle de types Les types en programmation Expressions de types Un contrôleur de types Equivalence de types Conversions de types Généricité.
CSI 1502 Principes fondamentaux de conception de logiciels
Texture 2D en PGC++.
Structures de données IFT-10541
Tableaux Introduction aux tableaux à une dimension. Déclaration, stockage, initialisation et accès en lecture ou en écriture aux composantes d’un tableau.
Patrons de conceptions de créations
201 UMLV  Type « dictionnaire » sous-ensembles finis de E (ordonné) avec les opérations : Ens_vide :  Ens Ajouter : Ens x Elément  Ens Enlever.
Structures des données
Le langage C Structures de données
(Vient du grec et signifie « Peut prendre plusieurs formes »)
Labo II : Tableaux et pointeurs
Labo 4 : Les structures et les entrées et sorties
1 Structures des données. 2  Le tableau permettait de désigner sous un seul nom un ensemble de valeurs de même type, chacune d'entre elles étant repérée.
Technologies web et web sémantique TP3 - XML. XML eXtensible Markup Language (langage extensible de balisage) – Caractéristiques: méta-langage = un langage.
Arbres binaires et tables de hachage
Master 1 SIGLIS Java Lecteur Stéphane Tallard Chapitre 1 – Objets et Classes Master 1 SIGLIS1Java Lecteur - Chapitre 1 Objets et classes.
ETNA – 1ème année Guillaume Belmas –
Les types composés Les enregistrements.
TABLEAUX des POINTEURS TRAITEMENT DE STRUCTURES
Cours LCS N°4 Présenté par Mr: LALLALI
Chapitre III Introduction aux objets et aux classes.
Conception de Programmes - IUT de Paris - 1ère année Conception de Programmes Objectifs et organisation du cours Introduction à la P.O.O.
Projet serveur Active Directory
8PRO107 Éléments de programmation Les adresses et les pointeurs.
Chaînage et LSC : motivation et principe Manipuler la LSC : exemples Variantes : LDC, liste circulaire, …  Etude de cas : réalisation d’un buffer clavier.
Informatique 2A Langage C 5ème séance. Déroulement de la séance 5 1 ère partie Étude des chaînes de caractères 2 ème partie Les structures 3.
Les structures de base Listes chainées. Listes Les listes(similaire aux tableaux) sont des structures informatiques qui permettent de garder en mémoire.
Int 10. Int 6.
Transcription de la présentation:

1 Exemples Construction et implantation de types de données abstraits

2 Dictionnaire.h /*Spécification fonctionnelle du type de donnée abstrait "Dictionnaire". Composantes :Chaque composante représente un mot. Structure :La structure choisie est un ensemble. Chaque composante est représentée de façon unique par le mot lui-même. Domaine :Les caractéristiques d'un mot sont : -le mot lui-même (au plus 20 caractères), -le nombre de définitions de ce mot, -les différentes définitions de ce mot (au plus 50 caractères par définition).*/

3 Dictionnaire.h typedef char definition_pour_un_mot[50+1]; struct mot { char nom_du_mot[20+1]; int nombre_de_definitions; definition_pour_un_mot * tableau_des_definitions_du_mot; mot * pMot_suivant; }; typedef mot * Dictionnaire;

4 Dictionnaire.h void Construire_dictionnaire(Dictionnaire *pD); /*Permet de construire un dictionnaire vide pointé par pD. Pré -Nil. Post -Nous avons un dictionnaire vide.*/ void Ajouter_Mot (Dictionnaire *pD, char *Nom_du_mot, intNombre_de_definitions ); /*Permet d'ajouter un nouveau mot au dictionnaire pD dont le nombre de définitions est fixé. Pré -Le dictionnaire a déjà été créé et le mot passé en para- mètre n'existe pas encore. Post -Un nouveau mot dont le nombre de définitions est passé en paramètre est ajouté au dictionnaire.*/

5 Dictionnaire.h void Inserer_Definition_Mot (Dictionnaire *pD, char *Nom_du_mot, inti, char *Definition ); /*Permet d'insérer la i ième définition du mot passé en paramètre. Pré -Le mot passé en paramètre fait déjà partie du dictionnaire pD. 1 <= i <= nombre_de_definitions. Post -La i ième définition de ce mot est insérée.*/

6 Dictionnaire.h bool Existe_Mot (Dictionnaire *pD, char *Nom_du_mot, int * Nombre_de_definitions ); /*Permet de déterminer si le mot passé en paramètre fait partie ou non du dictionnaire pD. Si oui, le nombre de définitions prévues est retourné. Pré -Le dictionnaire a déjà été créé. Post -Retourne true si ce mot existe, false sinon. Si le mot existe, le nombre de définitions prévues est retourné.*/

7 Dictionnaire.h char * Acces_Definition_mot (Dictionnaire *pD, char *Nom_du_mot, int i ); /*Donne accès à la i ième définition du mot passé en paramètre ou une chaîne vide si cette définition n'est pas disponible. Pré -Le mot passé en paramètre fait déjà partie du dictionnaire pD.1 <= i <= nombre_de_definitions. Post -Retourne la i ième définition du mot passé en paramètre.*/

8 Dictionnaire.cpp #include #include "Dictionnaire.h" #include void Construire_dictionnaire(Dictionnaire *pD) { *pD = NULL; }

9 Dictionnaire.cpp void Ajouter_Mot (Dictionnaire *pD, char *Nom_du_mot, intNombre_de_definitions) { int Nb_de_definitions; assert(Existe_Mot(pD, Nom_du_mot, &Nb_de_definitions) == false); mot * pMot = new mot; strcpy(pMot -> nom_du_mot, Nom_du_mot); pMot -> nombre_de_definitions = Nombre_de_definitions; pMot -> tableau_des_definitions_du_mot = new definition_pour_un_mot[Nombre_de_definitions]; for (int i = 0; i < Nombre_de_definitions; i++) strcpy(pMot -> tableau_des_definitions_du_mot[i], ""); pMot -> pMot_suivant = (*pD); *pD = pMot; }

10 Dictionnaire.cpp void Inserer_Definition_Mot (Dictionnaire *pD, char *Nom_du_mot, inti, char *Definition ) { int Nb_de_definitions; assert(Existe_Mot(pD, Nom_du_mot, &Nb_de_definitions)); assert((i >= 1) && (i <= Nb_de_definitions)); mot * pMot = *pD; while (strcmp(pMot -> nom_du_mot, Nom_du_mot) != 0) pMot = pMot -> pMot_suivant; strcpy((pMot ->tableau_des_definitions_du_mot)[i-1],Definition); }

11 Dictionnaire.cpp bool Existe_Mot (Dictionnaire *pD, char *Nom_du_mot, int * Nombre_de_definitions ) { mot * pMot = *pD; while (pMot != NULL) if (strcmp(pMot -> nom_du_mot, Nom_du_mot) == 0) {(* Nombre_de_definitions) = pMot -> nombre_de_definitions; return true; }else pMot = pMot -> pMot_suivant; return false; }

12 Dictionnaire.cpp char * Acces_Definition_mot (Dictionnaire *pD, char *Nom_du_mot, int i ) { int Nb_de_definitions; assert(Existe_Mot(pD, Nom_du_mot, &Nb_de_definitions)); assert((i >= 1) && (i <= Nb_de_definitions)); mot * pMot = *pD; while (strcmp(pMot -> nom_du_mot, Nom_du_mot) != 0) pMot = pMot -> pMot_suivant; return (pMot -> tableau_des_definitions_du_mot)[i-1]; }

13 Nouveau Dictionnaire.cpp #include "Dictionnaire.h" #include void main() { int i; int Nb_de_definitions; Dictionnaire Dict; Construire_dictionnaire(& Dict); Ajouter_Mot(&Dict, "corne", 2); Ajouter_Mot(&Dict, "belier", 3); Ajouter_Mot(&Dict, "etoile", 2); Ajouter_Mot(&Dict, "B.C.G.", 1);

14 Nouveau Dictionnaire.cpp Inserer_Definition_Mot(&Dict, "belier", 2, "Machine de guerre"); Inserer_Definition_Mot(&Dict, "belier", 1, "Mouton male reproducteur"); Inserer_Definition_Mot(&Dict, "belier", 3, "Signe du zodiaque"); Inserer_Definition_Mot(&Dict, "etoile", 2, "Animal marin"); Inserer_Definition_Mot(&Dict, "etoile", 1, "Astre"); Inserer_Definition_Mot(&Dict, "B.C.G.", 1, "Vaccin contre la tuberculose"); if (Existe_Mot(&Dict, "etoile", &Nb_de_definitions)) { for (i = 1; i <= Nb_de_definitions; i++) cout<< "etoile" << " " << i << " " << Acces_Definition_mot(&Dict, "etoile", i) << "\n"; }else cout << "Ce mot est absent.";

15 Nouveau Dictionnaire.cpp if (Existe_Mot(&Dict, "corne", &Nb_de_definitions)) { for (i = 1; i <= Nb_de_definitions; i++) cout << "corne" << " " << i << " " << Acces_Definition_mot(&Dict, "corne", i) << "\n"; }else cout << "Ce mot est absent."; if (Existe_Mot(&Dict, "plume", &Nb_de_definitions)) { for (i = 1; i <= Nb_de_definitions; i++) cout << "plume" << " " << i << " " << Acces_Definition_mot(&Dict, "plume", i) << "\n"; }else cout << "Ce mot est absent."; }

16 Polynome.h /*Spécification fonctionnelle du type de donnée abstrait "Polynome" Composantes:Chaque composante représente un terme du polynôme de degré n. Structure :La structure choisie est une suite de n+1 termes. i Domaine :Le i ième terme du polynôme est de la forme a x : i*/ struct Polynome { int degre; float * coefficients; };

17 Polynome.h void Construire_polynome(Polynome *pP, int n); /*Permet de construire un polynôme nul de degré n pointé par pP. Pré -Nil. Post -Nous avons un polynôme nul de degré n.*/ void Inserer_Terme (Polynome *pP, inti, floatCoefficient ); /*Permet d'insérer le i ième terme dont le coefficient est passé en paramètre. Pré -Le polynôme de degré "degre" a déjà été créé. 0 <= i <= degre. Post -Le i ième terme fait maintenant partie du polynôme.*/

18 Polynome.h float Acces_Coefficient_Terme (Polynome *pP, inti); /*Permet d'accéder au coefficient du i ième terme du polynôme pointé par pP. Pré -Le polynôme de degré "degre" a déjà été créé. 0 <= i <= degre. Post -Retourne le i ième coefficient du polynôme.*/ float Evaluer_polynome (Polynome * pP, float x ); /*Permet d'évaluer le polynôme à x et retourne le résultat. Pré -Le polynôme est déjà créé. Post -Retourne la valeur du polynôme évalué à x.*/

19 Polynome.h Polynome * Addition (Polynome * pP, Polynome * pQ ); /*Permet d'additionner les 2 polynômes passés en paramètres. Pré -Les 2 polynômes passés en paramètres ont été créés. Post -Retourne la somme de ces 2 polynômes.*/ Polynome * Soustraction (Polynome * pP, Polynome * pQ ); /*Permet de soustraire du premier le deuxième polynôme passés en paramètres. Pré -Les 2 polynômes passés en paramètres ont été créés. Post -Retourne la différence de ces 2 polynômes.*/

20 Polynome.cpp #include #include "Polynome.h" void Construire_polynome(Polynome *pP, int n) { (*pP).degre = n; (*pP).coefficients = new float[n+1]; for (int i = 0; i <= n; i++) (*pP).coefficients[i] = 0.0f; } void Inserer_Terme (Polynome *pP, inti, floatCoefficient ) { assert((i >= 0) && ( i <= (*pP).degre)); (*pP).coefficients[i] = Coefficient; }

21 Polynome.cpp float Acces_Coefficient_Terme (Polynome *pP, inti ) { assert((i >= 0) && ( i <= (*pP).degre)); return (*pP).coefficients[i]; } float Evaluer_polynome (Polynome * pP, float x ) {/*Règle de Horner*/ float somme = 0.0f; for ( int i = (*pP).degre; i >= 0; i--) somme = x * somme + (*pP).coefficients[i]; return somme; }

22 Polynome.cpp Polynome * Addition (Polynome * pP,Polynome * pQ ) { int n; if ((*pP).degre <= (*pQ).degre) n = (*pQ).degre; else n = (*pP).degre; Polynome * pR = new Polynome; Construire_polynome(pR, n); for(int i = 0; i <= (*pP).degre; i++) Inserer_Terme(pR, i, Acces_Coefficient_Terme(pP, i)); for(i = 0; i <= (*pQ).degre; i++) (*pR).coefficients[i] += Acces_Coefficient_Terme(pQ, i); return pR; }

23 Polynome.cpp Polynome * Soustraction (Polynome * pP,Polynome * pQ ) { int n; if ((*pP).degre <= (*pQ).degre) n = (*pQ).degre; else n = (*pP).degre; Polynome * pR = new Polynome; Construire_polynome(pR, n); for(int i = 0; i <= (*pP).degre; i++) Inserer_Terme(pR, i, Acces_Coefficient_Terme(pP, i)); for(i = 0; i <= (*pQ).degre; i++) (*pR).coefficients[i] -= Acces_Coefficient_Terme(pQ, i); return pR; }

24 Essai Polynome.cpp #include "Polynome.h" #include "iostream.h" void main() { Polynome P, Q; Construire_polynome(&P, 3); Construire_polynome(&Q, 5); Inserer_Terme(&P, 0, 3.5f);Inserer_Terme(&P, 2, -4.1f); Inserer_Terme(&P, 3, 2.3f); Inserer_Terme(&Q, 3, 2.7f);Inserer_Terme(&Q, 5, 1.0f); cout << "P(1) = " << Evaluer_polynome(&P, 1) << "\n"; cout << "Q(-1) = " << Evaluer_polynome(&Q, -1) << "\n"; cout << "(P + Q)(1) = " << Evaluer_polynome(Addition(&P, &Q), 1) << "\n"; cout << "(P - Q)(1) = " << Evaluer_polynome(Soustraction(&P, &Q), 1) << "\n"; }

25 Spécification fonctionnelle du type de donnée abstrait "Le_Banquier" En jouant au jeu LE BANQUIER, vous pouvez gagner jusqu'à $. Au départ, 26 valises closes renferment chacune un montant parmi les suivants : 0.01$1$1 000$5 000$ 5$10$10 000$15 000$ 20$50$25 000$50 000$ 75$100$75 000$ $ 200$300$ $ $ 400$500$ $ $ 750$ $ Le montant pour chaque valise est généré aléatoirement. Le montant dans une valise est inconnu du Banquier et du concurrent à moins que celui-ci l'est déjà choisi auparavant.

26 Pour débuter le jeu, le concurrent met en retrait une des 26 valises sans l'ouvrir. Puis, il passe au premier tour. À chaque tour, le concurrent doit ouvrir un certain nombre de valises comme suit : Tour # 1 :6 valises Tour # 2 :5 valises Tour # 3 :4 valises Tour # 4 :3 valises Tour # 5 :2 valises Tour # 6 :1 valise Tour # 7 :1 valise Tour # 8 :1 valise Tour # 9 :1 valise Tour # 10 :1 valise

27 À la fin d'un tour, à la lumière des montants dévoilés depuis le début du jeu, le Banquier fait un offre au concurrent. Celui-ci peut accepter l'offre; il repart alors avec le montant que le Banquier lui offre; le jeu est terminé. Le concurrent peut refuser l'offre; il passe alors au tour suivant. Si le concurrent se rend au dixième tour, toutes les valises sont ouvertes et le concurrent gagne le montant que renferme la valise mise en retrait. À chaque étape du jeu, on doit connaître les numéros de valises ouvertes avec leurs montants respectifs de même que les montants qui n'ont pas encore été choisis. On conserve aussi une trace des différentes offres que le Banquier a faites au concurrent.

28 const int Nombre_de_valises = 26; const float Ensemble_des_montants[Nombre_de_valises] = {0.01f,1,5,10, 20,50,75,100, 200,300,400,500, 750,1000,5000,10000, 15000,25000,50000,75000, ,125000,150000,200000, , }; const int Nombre_de_valises_a_chaque_tour[10] = {6,5,4,3,2,1,1,1,1,1};

29 struct Le_Banquier { bool Valises_ouvertes[Nombre_de_valises]; // TRUE si une valise est ouverte. // FALSE sinon. float Montants_des_valises[Nombre_de_valises]; // Montant associé à chaque valise. int Numeros_des_valises_associees_aux_montants [Nombre_de_valises]; // Numéro de la valise associé à chaque montant. int Numero_de_la_valise_en_retrait; // Numéro de la valise que le concurrent décide // de retirer au début du jeu.

30 float Offres_du_banquier[10]; // Offre du banquier à chaque tour où le concurrent // décide de poursuivre. bool Offre_du_banquier_acceptee; // TRUE si la dernière offre du banquier est acceptée. // FALSE autrement. int Numero_du_tour; // Numéro du tour actuel (entre 1 et 10). };

31 void Initier_le_jeu(Le_Banquier *pB); /*Permet de générer aléatoirement les montants dans les 26 valises d'un jeu pointé par pB. Pré -Nil. Post -Les montants des valises sont générés aléatoirement. Aucune valise n'est ouverte et la valise en retrait n'a pas encore été choisie par le concurrent. Aucune offre du banquier n'a été faite jusqu'à maintenant.*/ void Retrait_d_une_valise(Le_Banquier *pB, int i); /*Permet au concurrent de débuter le jeu en mettant la valise no. i en retrait. Pré -1 <= i <= 26. Les montants dans les 26 valises ont été générés. La valise en retrait n'a pas encore été choisie. Post -La valise no. i est mise en retrait.*/

32 void Ouverture_des_valises_au_prochain_tour (Le_Banquier *pB, int Numero_des_valises_a_ouvrir[]); /*Permet au concurrent de passer au tour suivant et de choisir les valises à ouvrir selon le tour où l'on est rendu. Cela signifie que le concurrent a rejeté l'offre du banquier si nous ne sommes pas au premier tour. Pré -Le nombre de tours effectué jusqu'à maintenant est ≤ 9. Le nombre de valises à ouvrir correspond exactement au nombre de valises prévu à ce tour. Les nos. de valises à ouvrir n'ont pas déjà été ouvertes et ne renferment pas le numéro de valise en retrait. Les offres du banquier ont toutes été rejetées jusqu'à maintenant. Post -Les valises choisies à ce tour sont ouvertes et une nouvelle offre du banquier est disponible. Si nous sommes au dixième tour, l'offre du banquier coïncide avec le montant de la valise en retrait et le concurrent accepte automatiquement l'offre du banquier.*/

33 float Offre_acceptee(Le_Banquier *pB); /*Permet d'accepter la dernière offre du banquier. Pré -Au moins un tour a été effectué. Les offres du banquier ont toutes été rejetées jusqu'à maintenant. Post -La dernière offre du banquier est acceptée et la valeur de cette offre est retournée.*/ bool Offre_acceptee_ou_refusee(Le_Banquier *pB); /*Retourne true si l'offre du banquier est acceptée. False autrement. Pré -Au moins un tour a été effectué. Post -Retourne true si l'offre du banquier est acceptée. False autrement.*/

34 float Derniere_offre_du_banquier(Le_Banquier *pB); /*Retourne la dernière offre du banquier. Pré -Au moins un tour a été effectué. Post -Retourne la dernière offre du banquier.*/ float Ouverture_de_la_valise_en_retrait(Le_Banquier *pB); /*Retourne le montant présent dans la valise en retrait. Pré -La dernière offre du banquier a été acceptée. Post -Retourne le montant présent dans la valise en retrait.*/ float Montant_espere_de_la_valise_en_retrait(Le_Banquier *pB); /*Retourne la moyenne des montants non encore sélectionnés.*/

35 float Montant_espere_avec_un_tour_ideal(Le_Banquier * pB); /*Retourne la moyenne des montants non encore sélectionnés après le prochain tour dans l'éventualité où le concurrent choisirait au prochain tour les valises dont les montants sont les plus petits. Pré -Le # de tours effectué jusqu'à maintenant est ≤ 9.*/ float Montant_espere_avec_un_tour_desastreux(Le_Banquier * pB); /*Retourne la moyenne des montants non encore sélectionnés après le prochain tour dans l'éventualité où le concurrent choisirait au prochain tour les valises dont les montants sont les plus élevés. Pré -Le # de tours effectué jusqu'à maintenant est ≤ 9.*/

36 float Montant_minimum_de_la_valise_en_retrait(Le_Banquier *pB); /*Retourne le minimum des montants non encore sélectionnés.*/ float Montant_maximum_de_la_valise_en_retrait(Le_Banquier *pB); /*Retourne le maximum des montants non encore sélectionnés.*/ void Affichage(Le_Banquier *pB); /*Permet d'afficher les montants des valises ouvertes et les numéros des valises closes.*/ float Offre_du_banquier(Le_Banquier *pB); /*Retourne l'offre du banquier à la fin de chaque tour. Pré -Au moins un tour a été effectué. Post -Retourne l'offre du banquier. Si 10 tours ont été effectués, l'offre du banquier coïncide avec le montant de la valise en retrait et le concurrent accepte automatiquement l'offre du banquier.*/

37 Raisonnement du BANQUIER {Montant espéré avec un tour idéal + Montant espéré avec un tour désastreux + Montant espéré de la valise en retrait} / 3 ?!!???..! Moyenne des montants espérés de la valise en retrait en considérant toutes les possibilités qui résultent du choix du concurrent au tour suivant.