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

Présentation au sujet: "1 Exemples Construction et implantation de types de données abstraits."— Transcription de la présentation:

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

2 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 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 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 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 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 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 8 Dictionnaire.cpp #include #include "Dictionnaire.h" #include void Construire_dictionnaire(Dictionnaire *pD) { *pD = NULL; }

9 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 25 Spécification fonctionnelle du type de donnée abstrait "Le_Banquier" En jouant au jeu LE BANQUIER, vous pouvez gagner jusqu'à 500 000$. 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$100 000$ 200$300$125 000$150 000$ 400$500$200 000$300 000$ 750$500 000$ 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 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 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 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, 100000,125000,150000,200000, 300000,500000 }; const int Nombre_de_valises_a_chaque_tour[10] = {6,5,4,3,2,1,1,1,1,1};

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