/* ATTENTION : cette solution est adaptée à l'énoncé de
   l'exercice, mais n'est pas complète au point d'en faire une
   classe réutilisable par quiconque.
   Il faudrait redéfinir le constructeur de recopie, l'opérateur
   d'affectation, traiter les exceptions...
*/

#define NULL 0

template
  <class T>
class PileNonBornee
{
private:
  class Chainon {
    public:
      T        elt;
      Chainon* suiv;
    public:
      Chainon(T e, Chainon* s = NULL)
	: elt(e), suiv(s) {};
      ~Chainon() {
	if (suiv) delete suiv; }};
private:
  Chainon* dernier;
public:
  PileNonBornee();
  ~PileNonBornee();
public:
  PileNonBornee<T>& empiler(T);
  PileNonBornee<T>& depiler();
  T sommet();
  bool est_vide();
};

template
  <class T>
PileNonBornee<T>::PileNonBornee()
: dernier(NULL)
{};

template
  <class T>
PileNonBornee<T>::~PileNonBornee() {
  if (dernier != NULL) delete dernier; };

template
  <class T>
PileNonBornee<T>& PileNonBornee<T>::empiler(T e) {
  dernier = new Chainon(e, dernier);  
  return *this; };

template
  <class T>
PileNonBornee<T>& PileNonBornee<T>::depiler() {
  if (dernier) {
    Chainon* t = dernier->suiv;
    dernier->suiv = NULL;
    delete dernier;
    dernier = t; };
  return *this; };

template
  <class T>
T PileNonBornee<T>::sommet() {
  if (dernier)
    return dernier->elt; };

template
  <class T>
bool PileNonBornee<T>::est_vide() {
  return dernier == NULL; };