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

template <class T>
class stack;        //forward declaration for a template class

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

template <class T>
class stack {
public:
	typedef T value_type;
private:
	static const size_t max_size = 100;
	static size_t x;   //just to demonstrate the syntax
	T a[max_size];
	size_t n;          //stack pointer: subscript of next free element
public:
	stack<T>(): n(0) {}
	~stack<T>();

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

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

template <class T>
size_t stack<T>::x = sizeof (stack<T>);   //definition of static data member

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

//Push a value onto the stack.

template <class T>
void stack<T>::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>
T& stack<T>::pop()
{
	if (n == 0) {          //underflow
		cerr << "Can't pop when size " << n << " == 0.\n";
		exit(EXIT_FAILURE);
	}

	return a[--n];
}

template <class T>
bool operator==(const ::stack<T>& s1, const ::stack<T>& 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>
inline bool operator!=(const ::stack<T>& s1, const ::stack<T>& s2) {
	return !(s1 == s2);
}
#endif