GESTION D'UNE PILE PAR LES CLASSES

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

template <class T> class Cl_Pile;
//--------------------------------------------------------
//                      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(){NbrElts--;};
      friend class Cl_Pile <T> ;
  };//end class 
//--------------------------------------------------------
//                      FIN CLASSE Cl_Elt
//--------------------------------------------------------
  template<class T> 
  int Cl_Elt<T>::NbrElts = 0;

//--------------------------------------------------------
//                      DEBUT CLASSE Cl_Pile
//--------------------------------------------------------
  template <class T> 
  class Cl_Pile{ 
    private:
      void Inserer(Cl_Elt <T> *);
    public: 
      Cl_Elt<T> *pTete; 
      Cl_Pile(){pTete=NULL;};
      void Empiler (const T); 
      void Depiler();
      void Affichage();
      void TestPileVide();  
      void NbrElements(void){cout << Cl_Elt<T>::NbrElts;}; 
  };//end class 
//--------------------------------------------------------
//                      FIN CLASSE Cl_Pile
//--------------------------------------------------------

//------------------------------------------------------------------------------
// FONCTION      : Empiler
// DESCRIPTION   : Création d'un Elt et Empilage dans la Pile
//-------------------------------------------------------------------------------
  template<class T> 
  void Cl_Pile<T>::Empiler(T val){
  //Allocation memoire pour un nouveau Elément de la Pile. 
    Cl_Elt <T> * pEltTmp = new Cl_Elt <T>; 

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

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

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

  }//end process

//------------------------------------------------------------------------------
// FONCTION      : Inserer
// DESCRIPTION   : Insertion d'un Elt dans la Pile
//-------------------------------------------------------------------------------
  template <class T> 
  void Cl_Pile<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 (pTete == NULL){ 
      pTete = 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 = pTete; 
    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      : Depiler
// DESCRIPTION   : Retire un élément de la Pile et l'affiche
//-------------------------------------------------------------------------------
  template <class T> 
  void Cl_Pile<T>::Depiler(){ 

  //Si la Pile vide, on sort 
    if (pTete == NULL){ 
      cout << "Pile vide!" << endl;
      return; 
    }//end if 

  //Création de deux pointeurs de déplacement dans la Pile et initilisation
    Cl_Elt<T> * courant = pTete; 
    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){ 
      if (courant->suivant == NULL){
        cout << "| " << courant->valeur << " |" << endl;
        if (precedent != NULL) 
          precedent->suivant = NULL;
         else
           pTete = NULL;
        break; 
       }else{
         precedent = courant; 
         courant = courant->suivant; 
      }//end if
    }//end while
    delete courant; 

  }//end process 

//------------------------------------------------------------------------------
// FONCTION      : Affichage
// DESCRIPTION   : Affiche le contenu de la Pile à l'écran
//-------------------------------------------------------------------------------
  template <class T> 
  void Cl_Pile<T>::Affichage(){ 
 //Si pTete différent de NULL alors il affiche le contenu de la Pile
   if(pTete!=NULL){ 
      Cl_Elt<T> * courant = pTete; 
  
      while (courant){ 
        cout << "|" << courant->valeur; 
        courant = courant->suivant; 
      }//end while
      cout << "|" << endl;
   }else
       cout << "Pile vide!" << endl;
   //end if
  }//end process 
//------------------------------------------------------------------------------
// FONCTION      : TestPileVide
// DESCRIPTION   : Controle si la Pile est vide
//-------------------------------------------------------------------------------
  template <class T> 
  void Cl_Pile<T>::TestPileVide(){ 
    if(pTete==NULL) 
      cout << "\nPile vide!" << endl;
     else
       cout << "\nPile non vide!" << endl;
    //end if
  }//end process 
//------------------------------------------------------------------------------
//                      START PROGRAM TEST CLASS
//-------------------------------------------------------------------------------
  void main(){
     Cl_Pile <int> stack;
     stack.Empiler(5);
     stack.Empiler(10);
     stack.Affichage();
     stack.Depiler();
     stack.Depiler();
     stack.Depiler();
     cout << "Nombre d'éléments : " ;
     stack.NbrElements();
     stack.TestPileVide(); 


  }//end program
//------------------------------------------------------------------------------
//                      END PROGRAM TEST CLASS
//-------------------------------------------------------------------------------