GESTION D'UNE FILE PAR LES CLASSES

#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
//-------------------------------------------------------------------------------