Gestion d'une pile par les classes
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
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
//-------------------------------------------------------------------------------
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.