La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Structures de données IFT-2000 Abder Alikacem Les listes ordonnées Programmation générique en C++ Semaine 3, suite et fin Département dinformatique et.

Présentations similaires


Présentation au sujet: "Structures de données IFT-2000 Abder Alikacem Les listes ordonnées Programmation générique en C++ Semaine 3, suite et fin Département dinformatique et."— Transcription de la présentation:

1 Structures de données IFT-2000 Abder Alikacem Les listes ordonnées Programmation générique en C++ Semaine 3, suite et fin Département dinformatique et de génie logiciel Édition Septembre 2009

2 Deuxième partie Retour au type abstrait liste ordonnée, implantation par: des tableaux dynamiques (lab#3) des listes simplement chaînées des listes doublement chaînées des listes circulaires (anneaux)

3 Les listes ordonnées Implantation dans une liste chaînée // fichier Noeud.h // déclaration de la classe Noeud #ifndef NOEUD_H #define NOEUD_H class Noeud; typedef Noeud * elem; template class Noeud{ //Un noeud typique de la liste public: T el;//L'élément de base de la liste elem suivant;//Un pointeur vers le noeud suivant Noeud (const T& data_item, elem next_ptr = 0) : el(data_item), suivant(next_ptr) {} ~Nœud(){}; }; #endif el suivant

4 Les listes ordonnées Implantation dans une liste chaînée #ifndef LISTE_H #define LISTE_H #include "Noeud.h" #pragma warning( disable : 4290 ) template class Liste { public: Liste(){debut = 0;} // constructeur ~Liste(); // destructeur Liste(const Liste&) throw(bad_alloc);// constructeur de copie void ajouter(T x, int pos) throw(range_error, bad_alloc); int taille() const; bool appartient(constT& x,) const; //Surcharge d'opérateurs Liste & operator = (const Liste &) throw (bad_alloc); friend ostream& operator << (ostream&, const Liste& ); private: elem debut; // Pointeur vers le dernier noeud de la liste } ; #endif

5 Implantation dans une liste chaînée Une meilleure version: utilisation dune classe interne //… template class Liste { public: //Constructeurs Liste(){debut = 0;}// constructeur Liste(const Liste&) throw(bad_alloc);// constructeur de copie ~Liste();// destructeur //Surcharge d'opérateurs Liste & operator = (const Liste &) throw (bad_alloc); private: class Noeud{//Un noeud typique de la liste public: T el;//L'élément de base de la liste Noeud * suivant; //Un pointeur vers le noeud suivant Noeud (const T& data_item, Noeud * next_ptr = 0) : el(data_item), suivant(next_ptr) {} }; typedef Noeud * elem; elem debut; //Pointeur vers le premier noeud de la liste } ;

6 Implantation dans une liste chaînée template Liste :: ~Liste() { elem courant = debut; while(courant!=0) { debut=debut->suivant; delete courant; courant=debut; } ~Liste() // destructeur Destructeur

7 Implantation dans une liste chaînée template void Liste :: ajouter(T x, int pos) throw(range_error, bad_alloc) { elem courant;//pointeur de service pour se promener dans la liste elem nouveau;//pour l'adresse de la nouvelle structure pour entreposer x int cpt=1;//compteur de boucle //Vérification des hypothèses (préconditions) //La position if(pos taille() +1) throw range_error(..:Position d'ajout erronée"); //La mémoire nouveau = new Noeud(x); //on appelle le constructeur de la classe Noeud //suite prochaine diapositive ajouter() // lajout délément

8 Implantation dans une liste chaînée //Cas où l'ajout se fait en première position if(pos==1) { nouveau->suivant=debut; debut = nouveau; return ; } //Ajout dans une autre quelconque position courant = debut;//on se positionne au début de la liste chaînée while (cpt< pos - 1) { courant=courant->suivant;//on passe à la structure suivante.. cpt++;//...et on compte } //A: courant pointe la structure d'avant le nouvel ajout nouveau->suivant = courant->suivant; //on chaîne la nouvelle structure … courant->suivant = nouveau;//on chaîne la structure qui doit précéder … } ajouter() // lajout délément

9 Implantation dans une liste chaînée template void Liste :: enleverEl(const T& x) throw(logic_error) { elem trouve = debut; elem pred; //on prend pour acquis que l'opérateur != s'applique sur x, le mieux est … while (trouve != 0 && trouve->el != x ) { pred = trouve; // pour marquer le noeud prédécesseur à celui qui contient x trouve = trouve->suivant; } if (trouve== 0) throw logic_error("EnleverEl: x n'est pas dans la liste"); else { //suite prochaine diapositive enleverEl() // enlever la première occurrence dun élément

10 Implantation dans une liste chaînée else { if (debut == trouve) { / x est au début de la liste debut = debut->suivant; } else { //..il est ailleur pred->suivant = trouve->suivant; } // on "coupe" la structure supprimée de la liste trouve->suivant = 0; //libération de la mémoire associée à la structure supprimée delete trouve; } enleverEl() // enlever la première occurrence dun élément

11 Implantation dans une liste chaînée template Liste & Liste ::operator = (const Liste & source)throw(bad_alloc) { //nettoyage... if (debut!=0) {elem temp= debut; while (debut !=0) { debut = temp->suivant; delete temp; temp = debut; } //suite prochaine diapositive Operator = () // surcharge de lop. daffectation

12 Implantation dans une liste chaînée if (source.debut== 0) debut = 0; // la liste originale est vide else { //la copie try{ //copie le permier noeud debut = new Noeud(source.debut->el); // copie le reste de la liste elem nouveau = debut; for(elem temp = source.debut->suivant; temp != 0;temp = temp->suivant) { nouveau->suivant = new Noeud(temp->el); nouveau = nouveau->suivant; } }catch(exception&){ //suite dans la prochaine diapositive Operator = () // surcharge de lop. daffectation

13 Implantation dans une liste chaînée catch(exception&){ //Si on arrive ici c'est qu'il y a une erreur d'allocation //On doit donc libérer la mémoire déjà allouée elem temp= debut; while (temp!=0) { debut = temp->suivant; delete temp; temp = debut; } //On relance alors l'exception pour indiquer qu'une erreur est survenue throw; } }//else return (*this); } Operator = () // surcharge de lop. daffectation

14 Implantation dans une liste chaînée template class Liste { public: //.. friend ostream& operator << (ostream& f, const Liste& l){ elem courant=l.debut; while(courant!=0) { f el << " "; courant=courant->suivant; } return f; } private: //.. } ; Operator << () // surcharge de lop. <<

15 Les listes chaînées circulaires permettent de rendre lécriture de certains algorithmes dune manière plus efficace. sommet... Implantation dans une liste circulaire (anneau) Cependant, il est plus intéressant davoir un pointeur dernier au lieu dun pointeur sommet dernier...

16 Listes circulaires (les anneaux) template class Liste { public: //... friend ostream& operator << (ostream& f, const Liste& l){ if(l.dernier == 0) return f; elem courant = l.dernier->suivant; while(courant!=l.dernier){ f el suivant; } f el; return f; } private: class Noeud{ public: T el; Noeud * suivant; Noeud (const T& data_item, Noeud * next_ptr = 0) : el(data_item), suivant(next_ptr) {} }; typedef Noeud * elem; elem dernier;/*Pointeur vers le dernier noeud de la liste*/ } ;

17 Dans les situations où il est souvent nécessaire datteindre des éléments d'une chaîne qui se trouvent quelques positions avant un élément donné, on peut alors adjoindre, à chaque élément, un pointeur supplémentaire vers son prédécesseur. SommetGSommetD … Implantation dans une liste doublement chaînée Nœud typique dune liste chaînée : Nœud typique dune liste doublement chaînée : Info LienPtrG Info PtrD

18 Implantation dans une liste doublement chaînée template class Liste { public: //.. private: class Noeud{//Un noeud typique de la liste public: T el;//L'élément de base de la liste Noeud * suivant;//Un pointeur vers le noeud suivant Noeud * precedent;//Un pointeur vers le noeud précédent Noeud (const T& data_item, Noeud * next_ptr = 0, Noeud * pred_ptr =0) : el(data_item), suivant(next_ptr), precedent(pred_ptr){} }; typedef Noeud * elem; elem sommetG;//Pointeur vers le sommet à gauche elem sommetD;//...vers le sommet droit int cpt;//cardinalité de la liste } ;

19 Liste doublement chaînée Ajouter un élément Ajouter N avant P : …… P N

20 Ajouter un élément Ajouter N avant P : P precedent suivant = N N precedent = P precedent N suivant = P P precedent = N …… P N Liste doublement chaînée

21 Ajouter un élément Ajouter N avant P : P precedent suivant = N N precedent = P precedent N suivant = P P precedent = N … … P N Liste doublement chaînée

22 Ajouter un élément Ajouter N avant P : P precedent suivant = N N precedent = P precedent N suivant = P P precedent = N …… P N Liste doublement chaînée

23 Ajouter un élément Ajouter N avant P : P precedent suivant = N N precedent = P precedent N suivant = P P precedent = N …… P N Liste doublement chaînée

24 Ajouter un élément Ajouter N avant P : P precedent suivant = N N precedent = P precedent N suivant = P P precedent = N …… P N Liste doublement chaînée

25 Ajouter un élément Ajouter N avant P : P precedent suivant = N N precedent = P precedent N suivant = P P precedent = N …… P N Liste doublement chaînée

26 Ajouter un élément Ajouter N après le sommet droit : … P N … Liste doublement chaînée template class Liste { public: //.. private: … elem sommetG; elem sommetD; int cpt; } ;

27 Ajouter un élément Ajouter N après le sommet droit : sommetD suivant = N N precedent = sommetD sommetD = N N suivant = 0 … P N … Liste doublement chaînée

28 Ajouter un élément Ajouter N après le sommet droit : sommetD suivant = N N precedent = sommetD sommetD = N N suivant = 0 … P N … Liste doublement chaînée

29 Ajouter un élément Ajouter N après le sommet droit : sommetD suivant = N N precedent = sommetD sommetD = N N suivant = 0 … P N … Liste doublement chaînée

30 Ajouter un élément Ajouter N après le sommet droit : sommetD suivant = N N precedent = sommetD sommetD = N N suivant = 0 … P N … Liste doublement chaînée

31 Ajouter un élément Ajouter N après le sommet droit : sommetD suivant = N N precedent = sommetD sommetD = N N suivant = 0 … P N … Liste doublement chaînée

32 Supprimer un élément Supprimer le nœud avant P …… P Liste doublement chaînée

33 Supprimer un élément Supprimer le nœud avant P N = P precedent P precedent = P precedent precedent P precedent suivant = P N suivant = 0 N precedent = 0 delete N N = 0 …… P N Liste doublement chaînée

34 Supprimer un élément Supprimer le nœud avant P N = P precedent P precedent = P precedent precedent P precedent suivant = P N suivant = 0 N precedent = 0 delete N N = 0 …… P N Liste doublement chaînée

35 Supprimer un élément Supprimer le nœud avant P N = P precedent P precedent = P precedent precedent P precedent suivant = P N suivant = 0 N precedent = 0 delete N N = 0 …… P N Liste doublement chaînée

36 Supprimer un élément Supprimer le nœud avant P N = P precedent P precedent = P precedent precedent P precedent suivant = P N suivant = 0 N precedent = 0 delete N N = 0 …… P N Liste doublement chaînée

37 Supprimer un élément Supprimer le nœud avant P N = P precedent P precedent = P precedent precedent P precedent suivant = P N suivant = 0 N precedent = 0 delete N N = 0 …… P N Liste doublement chaînée

38 Supprimer un élément Supprimer le nœud avant P N = P precedent P precedent = P precedent precedent P precedent suivant = P N suivant = 0 N precedent = 0 delete N N = 0 …… P N Liste doublement chaînée

39 Supprimer un élément Supprimer le nœud P …… P Liste doublement chaînée

40 Supprimer un élément Supprimer le nœud P P precedent suivant = P suivant P suivant precedent = P precedent P precedent = 0 P suivant = 0 delete P …… P Liste doublement chaînée

41 Supprimer un élément Supprimer le nœud P P precedent suivant = P suivant P suivant precedent = P precedent P precedent = 0 P suivant = 0 delete P …… P Liste doublement chaînée

42 Supprimer un élément Supprimer le nœud P P precedent suivant = P suivant P suivant precedent = P precedent P precedent = 0 P suivant = 0 delete P …… P Liste doublement chaînée

43 Supprimer un élément Supprimer le nœud P P precedent suivant = P suivant P suivant precedent = P precedent P precedent = 0 P suivant = 0 delete P …… P Liste doublement chaînée

44 Supprimer un élément Supprimer le nœud P P precedent suivant = P suivant P suivant precedent = P precedent P precedent = 0 P suivant = 0 delete P …… P Liste doublement chaînée

45 Supprimer un élément Supprimer le sommet gauche … N … Liste doublement chaînée template class Liste { public: //.. private: … elem sommetG; elem sommetD; int cpt; } ;

46 Supprimer un élément Supprimer le sommet gauche N = sommetG sommetG = sommetG suivant sommetG precedent = 0 N suivant = 0 delete N N = 0 … N … Liste doublement chaînée

47 Supprimer un élément Supprimer le sommet gauche N = sommetG sommetG = sommetG suivant sommetG precedent = 0 N suivant = 0 delete N N = 0 … N … Liste doublement chaînée

48 Supprimer un élément Supprimer le sommet gauche N = sommetG sommetG = sommetG suivant sommetG precedent = 0 N suivant = 0 delete N N = 0 … N … Liste doublement chaînée

49 Supprimer un élément Supprimer le sommet gauche N = sommetG sommetG = sommetG suivant sommetG precedent = 0 N suivant = 0 delete N N = 0 … N … Liste doublement chaînée

50 Supprimer un élément Supprimer le sommet gauche N = sommetG sommetG = sommetG suivant sommetG precedent = 0 N suivant = 0 delete N N = 0 … N … Liste doublement chaînée

51 Liste avec tableau: 1. Insertion et suppression sont en O(n). 2. Accès direct est en O(1). 3. Tout lespace est alloué à lavance. 4. Pas despace autre que les valeurs. Liste dans une liste chaînée: 1. Insertion et suppression sont en O(1). 2. Accès direct est en O(n). 3. Lespace augmente avec la liste. 4. Chaque élément requiert de lespace pour les pointeurs Comparaison des implantations de la liste

52 Éléments du C++ à consulter Semaine 1 Du C au C++ Les entrées/sorties (important pour cette semaine) Semaine 2 Concepts orientés objet Classe et objet L'espace de nommage Les types vector et string Semaine 3 Programmation générique (template) La gestion des exceptions

53 Éléments du C++ à maîtriser Les éléments syntaxiques nouveaux par rapport au langage C déclaration et initialisation de variables le type bool, lattribut const surcharge de fonctions et arguments par défaut transtypage, espace de nommage et opérateur de résolution de portée Notion de classe, constructeurs, destructeur les attributs de masquage Constructeur de copie et surcharge de l'op. = (minimum exigé dans une classe) Les attributs et méthodes d'une classe: friend, static, const La généricité (template)

54 Le point sur les normes de programmation Normes de programmation: Commentaires dinterface Commentaires dimplémentation Découpage logique dun programme La gestion des exceptions Style de programmation Voir sur le site Web du cours, section Documentations/Normes de programmation: NormesProgrammation.pdf Resume.h (à propos des commentaires Doxygen)

55 Nom de la classe Catégorie Description domain_error logique Lancée s'il se produit une erreur de domaine mathématique. invalid_argument logique Lancée si un des arguments d'une fonction est invalide. length_error logique Lancée si un objet aura une taille invalide. out_of_range logique Lancée si il y a une erreur avec un indice. logic_error logique Lancée lors de n'importe quel autre problème de logique du programme. Gestion des exceptions #include

56 Résumé des balises de Doxygen L'interface... /** * \brief * * \pre * * \post * * \exception */ Implémentation... /** * \fn * * \param[in] * \param[out] * * \return Section Documentations/Normes de programmation: Resume.h (à propos des commentaires Doxygen) En-tête de fichiers /** * \file Liste.cpp * \brief Le code des opérateurs de la liste. * \author Abder * \version 0.1 * \date septembre 2009 * * Implémentation de la classe générique Liste. * */

57 template class Liste{ public://L'interface... /** * \brief Ajouter un nouvel élément dans la liste * * \pre il y a assez de mémoire pour ajouter l'élément x * \pre la position d'ajout, pos, est comprise entre 1 et |L|+1 * * \post la liste comprend un élément de plus * \post la liste est inchangée sinon * * \exception range_error si la position est erronée * \exception length_error si pas assez de mémoire */ void ajouter(T x, int pos) throw(range_error, length_error);... private:...//Modèle d'implantation }; Fichier Liste.h Spécifications « C++ » (version Doxygen)

58 /** * \fn void Liste :: ajouter (T x, int pos) * * \param[in] x Élément à ajouter * \param[in] pos Position où insérer l'élément * */ template void Liste ::ajouter (T x, int pos) throw(out_of_range, length_error) { Commentaires dimplémentation (version Doxygen)

59 Structures de données IFT-2000 Abder Alikacem Les structures de piles et de files Semaine 4 Département dinformatique et de génie logiciel Édition Septembre 2009

60 Première partie: les piles Introduction et exemples dapplication Description en terme de type abstrait Implantation Piles : LIFO : last in, first out DAPS : dernier arrivé, premier sorti inout pile

61 Les primitives de manipulation ajouter un nouvel élément sur la pile (empiler, push) enlever un élément de la pile (dépiler, pop) regarder le premier élément de la pile (sommet, top) indiquer si la pile est vide regarder si un élément est sur la pile (examiner, peep) remplacer un élément sur la pile (changer, change) pile Piles Préoccupation de la programmation par objet initialiser une pile (constructeurs); détruire une pile de ses éléments (destructeur); Constructeur de copie; Surcharge de lopérateur =

62 La classe Pile template class Pile { public: // constructeurs et destructeurs Pile();//constructeur Pile(const Pile&) throw(bad_alloc); //constructeur copie ~Pile();//destructeur // Modificateurs void empiler(T) throw (bad_alloc); T depiler() throw(logic_error); //Sélecteurs bool estVide(); int taille(); T& sommet() throw (logic_error); // élément au sommet //surcharge d'opérateurs Pile & operator = (const Pile &) throw (bad_alloc); friend ostream& operator << (ostream&, const Pile& ); private: …//Modèle dimplantation };

63 Piles : implantation dans un tableau template class Pile { public: Pile(const int max = MAX) throw (bad_alloc); // constructeur... ~Pile (); // destructeur private : T* tab; int sommet; int tailleMax; }; Implantation dans un tableau dynamique

64 Piles : implantation dans un tableau template Pile :: Pile (int max) throw (bad_alloc){ tab = new T [max]; sommet = -1; tailleMax =max; } template Pile :: ~Pile (void) { if (tab!=0) delete [ ] tab; } Constructeur Destructeur

65 Piles : implantation dans un tableau template T Pile :: depiler(void) throw (logic_error){ if (!estVide()) return tab[sommet--]; else throw logic_error("Depiler: la pile est vide!"); } template bool Pile :: estVide (void){ return (sommet == -1); } dépiler Sélecteur : vide

66 Piles : implantation dans un tableau template void Pile :: empiler(const T& e) throw (length_error){ if (sommet+1 < tailleMax) {sommet ++; tab[sommet] = e; } else throw length_error("Empiler:la pile est pleine\n"); } empiler Remarque : on suppose que l opérateur d affectation existe ou est surchargé dans la classe qui correspond au paramètre T. => intérêt de la surcharge des opérateurs

67 Piles : implantation dans un tableau template Pile & Pile :: operator = (const Pile & p) { if (tab!=0) delete [ ] tab; //on nettoie this tab=new T [p. tailleMax]; tailleMax =p.tailleMax; for (int i=0; i< tailleMax;i++) tab[i]=p.tab[i]; sommet=p.sommet; return (*this); //retourner : une référence sur l objet courant } Surcharge de lop. =

68 Piles : implantation dans un tableau template Pile :: Pile (const Pile & p) { tab=new X [p. tailleMax]; tailleMax =p. tailleMax; for (int i=0; i< tailleMax;i+=1) tab[i]=p.tab[i]; sommet=p.sommet; } Constructeur de copie

69 Piles : implantation dans une liste chaînée template class Noeud{ public: Noeud (const T& data_item, Noeud * next_ptr = 0) : el(data_item), suivant(next_ptr) {}//constructeur ~Noeud () {}; //destructeur qui ne fait rien }; friend class Pile ; private : T el; Noeud * suivant; Version 1 Implantation dans une liste chaînée

70 Piles : implantation dans une liste chaînée template class Pile { public: Pile (); // Constructeur Pile (const pile &) throw (bad_alloc); // Constructeur par copie ~Pile (); // Destructeur Pile & operator=(const Pile & P); // P1 = P void empiler (const T& a) throw (bad_alloc); T depiler () throw (logic_error); T& sommet (void) throw (logic_error); // sélecteur : valeur //placée au sommet bool vide(); //sélecteur : est vide? }; private : Noeud * sommet; // pointeur sur le sommet de la pile int cpt; // Nombre d'élements de la pile void detruire (); //Méthode privée utile pour le destructeur // et lop. = Version 1

71 Piles : implantation dans une liste chaînée template class Pile { public: Pile (); Pile (const Pile &) throw (bad_alloc); ~Pile (); Pile & operator=(const Pile & P); //.. private: class Noeud{ public: T el; Noeud * suivant; Noeud (const T& data_item, Noeud * next_ptr = 0) : el(data_item), suivant(next_ptr) {} }; Noeud * sommet; //sommet de la pile int cpt; void detruire (); }; Version 2 Class Nœud interne

72 Piles : implantation dans une liste chaînée template Pile ::Pile () { sommet =0; cpt = 0; } template Pile :: ~Pile() { if (sommet != 0) detruire( );} template void Pile ::detruire () { Noeud * p; while (sommet != 0){ p=sommet->suivant; delete sommet; sommet=p; } constructeur destructeur

73 Les piles Comparaison des 2 implantations Toutes les implantations des opérations dune pile utilisant un tableau ou une liste chaînée prennent un temps constant i.e. en O(1). Par conséquent, dun point de vue defficacité, aucune des deux implantations nest mieux que lautre. Dun point de vue de complexité spatiale, le tableau doit déclarer une taille fixe initialement. Une partie de cet espace est perdue quand la pile nest pas bien remplie. La liste peut augmenter ou rapetisser au besoin mais demande un extra espace pour mémoriser les adresses des pointeurs.

74 Deuxième partie: les files Introduction et exemples dapplication Description en terme de type abstrait Implantation Files : FIFO : first in, first out PAPS : premier arrivé, premier sorti outin file

75 Files Primitives de manipulation : ajouter un nouvel élément dans la file (enfiler); ôter l'élément le plus ancien de la file (défiler); indiquer si la file d'attente est vide; retourner le premier et dernier élément; Préoccupation de la programmation par objet initialiser une file (constructeurs); détruire une file de ses éléments (destructeur); Constructeur de copie; Surcharge de lopérateur = in file

76 La classe File template class File { public: // constructeurs et destructeurs: File() throw(bad_alloc);//constructeur File(const File &) throw(bad_alloc);//constructeur copie ~File(); // modificateurs void enfiler(T) throw (length_error); T defiler() throw(logic_error); // sélecteurs int taille() { return cpt;} bool estVide() { return cpt==0; } bool estPleine() { return cpt==TailleMax; } T& premier() throw (logic_error);// élément en tête de la file T& dernier() throw (logic_error);// élément en queue de la file // surcharges d'opérateurs File & operator = (const File &) throw (bad_alloc); friend ostream& operator << (ostream& f, const File& q); private://...Modèle d'implantation };

77 TêteQueue Insérer 'Robert' TQ Paul René Marc Paul Paul René René Marc Marc Marc Marc Marc Jean Jean Jean Anne Anne T T T T T T T Q Q Q Q Q Q Q Débordement Vide Insérer 'Paul' Insérer 'Jean' Insérer 'René' Extraire 'Paul' Extraire 'René' Insérer 'Anne' Insérer 'Marc' Implantation par tableau circulaire

78 Implantation: liste circulaire q = (q + 1) modulo MAXELT

79 Files: implantation dans un tableau Implantation dans un tableau dynamique template class File { public: File(const int max = MAX) throw (bad_alloc); // constructeur... ~File (); // destructeur private : T* tab; int tete; int queue; int tailleMax; int cpt; }; Tableau tab réservé dans le tas Constructeur avec un paramètre : taille maximum

80 Files: implantation dans un tableau template File :: File (int max) throw (bad_alloc){ tab = new T [max]; tete = 0; queue = 0; cpt = 0; tailleMax =max; } template File :: ~File (void) { if (tab!=0) delete [ ] tab; } Constructeur Destructeur

81 Files: implantation dans un tableau template T File :: defiler() throw (logic_error){ if (cpt!=0) { T elementaDefiler = tab[tete]; tete = (tete+1)% tailleMax; cpt--; return elementaDefiler; } else throw logic_error("Defiler: la file est vide!"); } défiler

82 Files: implantation dans un tableau template T File :: enfiler(const T& e) throw (length_error){ if(cpt

83 Files: implantation par listes Implantation dans une liste chaînée template class File { public: File (); File (const File &) throw (bad_alloc); ~File (); File & operator=(const File & P); //.. private: class Noeud{ public: T el; Noeud * suivant; Noeud (const T& data_item, Noeud * next_ptr = 0) : el(data_item), suivant(next_ptr) {} }; typedef Noeud * elem; elem tete; // pointeur sur la tête de la file eleme queue; // Pointeur en queue de file int cpt; // cardinalité de la file };

84 Files: implantation par listes template Pile ::Pile () { tete =0; queue = 0; cpt = 0; } template File :: ~File() { if (tete != 0) { Noeud * p; while (tete != 0){ p=tete->suivant; delete tete; tete=p; } constructeur destructeur

85 Files prioritaires Gestion dune seule file insertion se fait selon la priorité éléments toujours triés selon leur priorité in file in file

86 Laboratoire #4 (suite du lab#3) Nous vous fournissons 3 packetages, un par projet/implantation que vous devez faire: tableau dynamique (Lab#3) liste doublement chaînée liste circulaire Implantation dune liste ordonnée Dans chacun d'eux, vous devez compléter le fichier.inl étant donné le modèle d'implantation décrit dans la partie privée de la classe Liste. Bien entendu, les 3 implantations demandées doivent être génériques. Ces 2 main()Ces 2 main() fournis sont pour tester les 3 packetages (séparément), un main() pour instancier une liste ordonnée d'entiers et un autre pour déclarer une liste d'objets définis dans la classe ClasseTests.h que nousClasseTests.h vous fournissons également.


Télécharger ppt "Structures de données IFT-2000 Abder Alikacem Les listes ordonnées Programmation générique en C++ Semaine 3, suite et fin Département dinformatique et."

Présentations similaires


Annonces Google