Implementing Stacks

    
template<class T,int max_size = 100>
class stack
{
public:
	stack() : m_end(m_arr) {}
	~stack()	{}
	
	unsigned int size() { return (unsigned int)(m_end - m_arr); }
	T& top() { return *(m_end - 1); }
	void pop() { if(m_end > m_arr) --m_end; }
	// should throw an exception, 

	// but just return true or false for simplicity

	bool push(const T& val) {
		if(size() < max_size)
		{
			*m_end = val;
			++m_end;
			return true;
		}
		else
			return false;
	}
private:
	T m_arr[max_size];
	T* m_end;
};
    

  
template<class T,int max_size = 100>
class queue
{
public:
	queue() : m_size(0), m_front(0), m_back(0) {}
	~queue(){}
	
	bool push(const T& val)
	{
		if(m_size < max_size)
		{
			node* n = new_node();
			n->val = val;
			if(m_front == 0)
				m_front = m_back = n;
			else
			{
				m_back->prev = n;
				m_back = n;
			}
			++m_size;
			return true;
		}
		else
			return false;
	}
	void pop()
	{
		if(m_size)
		{
			node* t = m_front->prev;
			delete m_front;
			m_front = t;
			--m_size;
		}
	}
	T& front()
	{
		return m_front->val;
	}
	unsigned int size()
	{
		return m_size;
	}	
private:
	unsigned int m_size;
	struct node
	{
		node* prev;
		T val;
	};
	node* new_node()
	{
		node* ret = new node;
		ret->prev = 0;
		return ret;
	}
	node* m_front;
	node* m_back;
};