#ifndef STACKH
#define STACKH
#include <iostream>   //iostream includes cstddef, which defines size_t
#include <cstdlib>
using namespace std;

template <class T, size_t MAX_SIZE>
class stack;

template <class T, size_t MAX_SIZE>
bool operator==(const stack<T, MAX_SIZE>& s1, const stack<T, MAX_SIZE>& s2);

template <class T, size_t MAX_SIZE = 100> //Don't write the = 100 anywhere else.
class stack {
public:
	typedef T value_type;
private:
	T a[MAX_SIZE];
	size_t n;   //stack pointer: subscript of next free element
public:
	stack(): n(0) {}
	~stack();

	void push(const T& t);
	T& pop();

	friend bool operator==<T, MAX_SIZE>(const stack& s1, const stack& s2);
};

template <class T, size_t MAX_SIZE>
stack<T, MAX_SIZE>::~stack()
{
	if (n != 0) {
		cerr << "Warning: stack still contains " << n << " value(s).\n";
	}
}

//Push a value onto the stack.

template <class T, size_t MAX_SIZE>
void stack<T, MAX_SIZE>::push(const T& t)
{
	if (n == MAX_SIZE) {   //overflow
		cerr << "Can't push when size " << n << " == capacity "
			<< MAX_SIZE << ".\n";
		exit(EXIT_FAILURE);
	}

	a[n++] = t;
}

//Pop a value off the stack.

template <class T, size_t MAX_SIZE>
T& stack<T, MAX_SIZE>::pop()
{
	if (n == 0) {          //underflow
		cerr << "Can't pop when size " << n << " <= 0.\n";
		exit(EXIT_FAILURE);
	}

	return a[--n];
}

template <class T, size_t MAX_SIZE>
bool operator==(const ::stack<T, MAX_SIZE>& s1, const ::stack<T, MAX_SIZE>& s2)
{
	if (s1.n != s2.n) {
		return false;
	}

	for (size_t i = 0; i < s1.n; ++i) {
		if (s1.a[i] != s2.a[i]) {
			return false;
		}
	}

	return true;
}

template <class T, size_t MAX_SIZE>
inline bool operator!=(const ::stack<T, MAX_SIZE>& s1,
                       const ::stack<T, MAX_SIZE>& s2) {
	return !(s1 == s2);
}
#endif