#ifndef STACK_H                  // Fichier Stack.h
#define STACK_H

#include <assert.h>

#include <iostream>

using namespace std;

template <class T>
class Stack;

template <class T>                                    // Pour les fonctions
ostream& operator<<(ostream& os, const Stack<T>& s);  // friend template.
                                                      // Il faut aussi <>
const int MAX = 10;

template <class T>
class Stack {

   friend ostream& operator<< <>(ostream& os, const Stack<T>& s);

 public :
            Stack(void);
            Stack(const Stack<T>& s);
            Stack<T>& operator=(const Stack<T>& s);
   virtual ~Stack(void);
   bool empty(void) const;
   int size(void) const;
   const T& top(void) const;
   void push(const T& t);
   T pop(void);

 private :

   T _stack[MAX];
   int _size;

   void _copy(const Stack<T>& s);
   void _destroy(void);
};


template <class T>
inline
Stack<T>::Stack(void) : _size(0) {}

template <class T>
inline
Stack<T>::Stack(const Stack<T>& s)
{
 _copy(s);
}

template <class T>
inline
Stack<T>& Stack<T>::operator=(const Stack<T>& s)
{
 if (this != &s)
 {
  _destroy();
  _copy(s);
 }
 return *this;
}

template <class T>
inline
Stack<T>::~Stack(void) {}

template <class T>
inline
bool Stack<T>::empty(void) const { return _size == 0; }

template <class T>
inline
int Stack<T>::size(void) const { return _size; }

template <class T>
inline
const T& Stack<T>::top(void) const {
 assert(!empty());
 return _stack[_size - 1];
}

template <class T>
inline
void Stack<T>::push(const T& t) {
 assert(_size < MAX);
 _stack[_size++] = t;
}

template <class T>
inline
T Stack<T>::pop(void) {
 assert(!empty());
 return _stack[--_size];
}

template <class T>
inline
void Stack<T>::_copy(const Stack<T>& s)
{
 _size = s._size;
 for(int i=0; i< _size; i++)
 {
  _stack[i] = s._stack[i];
 }
}

template <class T>
inline
void Stack<T>::_destroy(void)
{
}

template <class T>
inline
ostream& operator<<(ostream& os, const Stack<T>& s)
{
 os << endl ;
 os << " Une Stack<T> :" << endl;
 for(int i=s._size-1; i>=0; i--)
 {
  if (s._size==1)   os << "sommet & fond : ";
  else
  if (i==s._size-1) os << "       sommet : ";
  else
  if (i==0)         os << "         fond : ";
  else              os << "                ";

  os << s._stack[i];

  os << endl;
 }
 os << "~~~~~~~~~~~~~~~" << endl;

 return os;
}

#endif // STACK_H