Gestion d'une pile par les classes

Soyez le premier à donner votre avis sur cette source.

Snippet vu 10 267 fois - Téléchargée 26 fois

Contenu du snippet

Exemple de la gestion d'une pile élémentaire en utilisant
une classe dynamique. Ce code à été compilé avec Borland C++ 5.5

Source / Exemple :


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

A voir également

Ajouter un commentaire

Commentaire

Messages postés
331
Date d'inscription
jeudi 22 mai 2003
Statut
Membre
Dernière intervention
26 janvier 2009

Heu... t'a pile empile ses éléments à la queue ? Oo; c'est pas pratique, on est obligé de parcourir toute la liste pour insérer son élément... ya pas moyen de les mettre en tete?

autre probleme (plus perso): si je veux par exemple mettre une pile de char*... okay, j'alloque ma chaine, je l'insere,... mais quand est-ce que je la libere ?

fin vala...

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.