Next: La surcharge des
Up: La généricité
Previous: Mise en uvre
class pileEntier {
int *ppile ;
int *base ;
int taille ;
public:
pileEntier(const int t=0) ;
~pileEntier(void) ;
int depile(void) ;
void empile(const int valeur) ;
int estVide(void) const ;
int estPleine(void) const ;
} ;
inline pileEntier::pile(const int t) : taille(t)
{ base = ppile = new int [t] ; }
inline pileEntier::~pile(void) { delete[] base ; }
int pileEntier::depile(void) { return *(--ppile) ; }
void pileEntier::empile(const int valeur)
{ *(ppile(++)=valeur ; }
int pileEntier::estVide(void) const { return (ppile=base) ;}
int pileEntier::estPleine(void) const {
return (ppile - base)==taille ; }
La classe pileEntier est défini comme ci-dessus. Le principe reste identique
quelque soit le type de donnée à empiler. Avec cette structure, si on a
besoin d'une pile de caractères, il est nécessaire d'écrire une nouvelle
classe pileCar dont le code sera pratiquement identique à celui de pileInt.
La généricité répond à ce problème, en offrant une classe pile
générique indépendant du type de donnée :
template<class T>
class pile {
T *ppile ;
T *base ;
int taille ;
public:
pile(const int t=0) ;
~pile(void) ;
T depile(void) ;
void empile(const T valeur) ;
int estVide(void) const ;
int estPleine(void) const ;
} ;
template<class T>
inline pile<T>::pile(const int t) : taille(t)
{ base = ppile = new T [t] ; }
template<class T>
inline pile<T>::~pile(void) { delete[] base ; }
template<class T>
T pile<T>::depile(void) { return *(--ppile) ; }
template<class T>
void pile<T>::empile(const T valeur) { *(ppile(++)=valeur ; }
template<class T>
int pile<T>::estVide(void) const { return (ppile=base) ;}
template<class T>
int pile<T>::estPleine(void) const
{ return (ppile - base)==taille ; }
int main(void) {
pile<int> pi ;
pile<char> pc ;
while (! pi.estPleine() ) pi.empile(5) ;
...
On peut retrouver la généricité pour des fonctions génériques.
template<class T>
void echange(T &a, T &b) {
T temp = a ;
a = b ; b = temp ;
}