Gestion d'une file par les classes

Commenter

Contenu du snippet

Exemple de la gestion d'une File élémentaire en utilisant une classe dynamique.
File de type LIFO Last In First Out = mêle procédé que la Pile avec une petite modif dans
la procédure "Defiler".
Ce code à été compilé avec Borland C++ 5.5 (sans Bug apparent)

Source / Exemple : 


#include <stdio.h>
#include <iostream>
 using namespace std;

template <class T> class Cl_File;
//--------------------------------------------------------
//                      DEBUT CLASSE Cl_Elt
//--------------------------------------------------------
  template <class T> 
  class Cl_Elt{ 
    private:
      static int NbrElts;

    public: 
      Cl_Elt *suivant;   
      T valeur; 
      Cl_Elt(){NbrElts++;};
      ~Cl_Elt(){delete suivant;NbrElts--;};
      friend class Cl_File <T> ;
  };//end class 
//--------------------------------------------------------
//                      FIN CLASSE Cl_Elt
//--------------------------------------------------------
  template<class T> 
  int Cl_Elt<T>::NbrElts = 0;

//--------------------------------------------------------
//                      DEBUT CLASSE Cl_File
//--------------------------------------------------------
  template <class T> 
  class Cl_File{ 
    private:
      void Inserer(Cl_Elt <T> *);
    public: 
      Cl_Elt<T> *pDebut; 
      Cl_File(){pDebut=NULL;};
      ~Cl_File(){delete pDebut;};
      void EmFiler (const T); 
      void DeFiler();
      void Affichage();
      void TestFileVide();  
      int NbrElements(void){return Cl_Elt <T>::NbrElts;}; 
  };//end class 
//--------------------------------------------------------
//                      FIN CLASSE Cl_File
//--------------------------------------------------------
//------------------------------------------------------------------------------
// FONCTION      : EmFiler
// DESCRIPTION   : Création d'un Elt et Empilage dans la File
//-------------------------------------------------------------------------------
  template<class T> 
  void Cl_File<T>::EmFiler(T val){
  //Allocation memoire pour un nouveau Elément de la File. 
    Cl_Elt <T> * pEltTmp = new Cl_Elt <T>; 

  //Initialisation du pointeur pElt à NULL
    pEltTmp->suivant = NULL; 

  //Transfert de la valeur 
    pEltTmp->valeur = val; 

  //Insérer dans la File
    Inserer (pEltTmp); 

  }//end process

//------------------------------------------------------------------------------
// FONCTION      : Inserer
// DESCRIPTION   : Insertion d'un Elt dans la File
//-------------------------------------------------------------------------------
  template <class T> 
  void Cl_File<T>::Inserer(Cl_Elt <T> *_pElt){ 
  //Si le pElt est vide, on sort 
    if (!_pElt) return; 

  //Si la Pile vide, on lui accroche l'Elt et on sort 
    if (pDebut==NULL){ 
      pDebut = _pElt; 
      cout << "Création réussie!" << endl;
      return; 
    }//end if 

  //Création de deux pointeurs de déplacement dans la Pile et initilisation
    Cl_Elt<T> * courant = pDebut; 
    Cl_Elt<T> * precedent = NULL; 
  
  //On se déplace à travers la Pile jusqu'a ce que courant atteint la valeur NULL
  //precedent memorise l'adresse du dernier Elt
    while (courant){ 
      precedent = courant; 
      courant = courant->suivant; 
    }//end while
 
  //Maintenant on place le nouvel Elt en fin de Pile
    precedent->suivant = _pElt; 
    cout << "Création réussie!" << endl;
  }//end process 

//------------------------------------------------------------------------------
// FONCTION      : DeFiler
// DESCRIPTION   : Retire un élément de la File et l'affiche
//-------------------------------------------------------------------------------
  template <class T> 
  void Cl_File<T>::DeFiler(){ 

  //Si la File vide, on sort 
    if (pDebut == NULL){ 
      cout << "File vide!" << endl;
      return; 
    }//end if 
    Cl_Elt<T> * courant = pDebut; 

    cout << "|" << courant->valeur << "|" << endl;
    pDebut = courant->suivant;

    delete &courant; 

  }//end process 

//------------------------------------------------------------------------------
// FONCTION      : Affichage
// DESCRIPTION   : Affiche le contenu de la File à l'écran
//-------------------------------------------------------------------------------
  template <class T> 
  void Cl_File<T>::Affichage(){ 
 //Si pTete différent de NULL alors il affiche le contenu de la File
   if(pDebut!=NULL){ 
      Cl_Elt<T> * courant = pDebut; 
  
      while (courant){ 
        cout << "|" << courant->valeur; 
        courant = courant->suivant; 
      }//end while
      cout << "|" << endl;
   }else
       cout << "File vide!" << endl;
   //end if
  }//end process 
//------------------------------------------------------------------------------
// FONCTION      : TestFileVide
// DESCRIPTION   : Controle si la File est vide
//-------------------------------------------------------------------------------
  template <class T> 
  void Cl_File<T>::TestFileVide(){ 
    if(pDebut==NULL) 
      cout << "\nFile vide!" << endl;
     else
       cout << "\nFile non vide!" << endl;
    //end if
  }//end process 
//------------------------------------------------------------------------------
//                      START PROGRAM TEST CLASS
//-------------------------------------------------------------------------------
  void main(){
     Cl_File <int> stack;
     stack.EmFiler(5);
     stack.EmFiler(10);
     stack.EmFiler(7);
   stack.Affichage();
     stack.DeFiler();
     stack.DeFiler();
     stack.DeFiler();
     stack.DeFiler();
     cout << "Nombre Elts = " << stack.NbrElements() << endl;
  }//end program
//------------------------------------------------------------------------------
//                      END PROGRAM TEST CLASS
//-------------------------------------------------------------------------------

Conclusion :


Ceci n'est qu'un modéle élémentaire qui respecte normalement le procédé LIFO.

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (UKR6900)