#include <iostream>
#include <conio.h>

using namespace std;

const int DIM_MAX = 10;

template <class T>
class Pila {
public:
  // Costruttore di default.
  Pila();

  // Distruttore.
  ~Pila();

  // Costruttore per copia
  Pila(const Pila<T>& p);
  
  // Operatore di assegnamento
  Pila<T>& operator=(const Pila<T>& p);
  
  // Inserisce l'elemento `x' nella pila.
  void push(T x);

  // Estrae un elemento dalla pila.
  T pop();

  // Ritorna `true' se la pila e' vuota;
  // `false' altrimenti
  bool empty() const;

  // Ritorna la capacita' della pila.
  unsigned int capacita() const;

  // Ritorna il numero di elementi contenuti nella pila.
  unsigned int num_elementi() const;

private:
  // Puntatore ad un array di int che rappresenta la pila stessa.
  T* A;

  // Indica quanti elementi ci sono nella pila.
  int top;

  // Capacita' della pila.
  int dim;

  // Raddoppia la dimensione della pila.
  void raddoppia();
};

template <class T>
Pila<T>::Pila() {
  A = new T[DIM_MAX];
  top = 0;
  dim = DIM_MAX;
}

template <class T>
Pila<T>::~Pila() {
  delete[] A;
}

template <class T>
Pila<T>::Pila(const Pila<T>& p) {
  A = new T[p.dim];
  for (unsigned int i = 0; i < p.dim; i++)
    A[i] = p.A[i];
  top = p.top;
  dim = p.dim;
}
  
template <class T>
Pila<T>&
Pila<T>::operator=(const Pila<T>& p) {
  int dim_min = dim < p.dim ? dim : p.dim;
  for (unsigned int i = 0; i < dim_min; i++)
    A[i] = p.A[i];
  top = p.top;
  dim = dim_min;
  return *this;
}

template <class T>
void
Pila<T>::push(T x) {
  if (top == DIM_MAX)
    raddoppia();
  A[top] = x;
  ++top;
}

template <class T>
T
Pila<T>::pop() {
  if (empty())
    throw "Invocato metodo `pop()' su pila vuota!";
  --top;
  return A[top];
}

template <class T>
bool
Pila<T>::empty() const {
  if (top == 0)
    return true;
  else
    return false;
}

template <class T>
unsigned int
Pila<T>::capacita() const {
  return DIM_MAX;
}

template <class T>
unsigned int
Pila<T>::num_elementi() const {
  return top;
}

template <class T>
void
Pila<T>::raddoppia() {
  T* tmp = new T[2*dim];
  for (int i = 0; i < dim; ++i)
    tmp[i] = A[i];
  delete[] A;
  dim *= 2;
  A = tmp;
}

//%%%%%%%%%%%%%%%%%%%%%%% main di prova

int main() try {
  Pila<int> P1;
  Pila<char> P2;

  P1.push('a');
  P2.push('a');
  
  while (!P1.empty())
    cout << P1.pop() << endl;

  while (!P2.empty())
    cout << P2.pop() << endl;

  getch();
  return 0;
}
catch(const char* str) {
  cerr << "Eccezione: " << str << endl;
  getch();
}