堆栈模板

#include<iostream>
#include<string>

#include<cassert>

using namespace std;

template <class T>
class Stack{
	public:
		enum {DefaultStack=50,EmptyStack=-1};
		Stack();                                        //构造函数
		Stack ( int );                                            //重载构造函数
		~Stack();                                     //析构函数
		void push( const T &);
		T pop();
		T topNoPop() const;
		bool empty() const;
		bool full() const;
	private:
		T* elements;
		int top;
		int size;
		void allocate(){
			elements =new T[size];
			top=EmptyStack;
		}
		void msg(const char* m) const{
			cout<<" *** "<<m<<" *** "<<endl;
		}
		friend ostream& operator<<(ostream&,const Stack<T>&);//友元函数
};

template<class T>
Stack<T>::Stack(){
	size=DefaultStack;
	allocate();
}

template<class T>
Stack<T>::Stack(int s){
	if(s<0)s*=-1;
	else if(0==s)
		s=DefaultStack;
	size=s;
	allocate();
}

template <class T>
Stack<T>::~Stack(){
	delete [] elements;
}

template <class T>
void Stack<T>::push(const T &e){
    assert(!full());
	if(!full())
		elements[++top]=e;
	else
		msg("Stack full!");

}

template <class T>

T Stack<T>::pop(){
	assert(!empty());
	if(!empty())
		return elements[top--];
	else{
		msg("Stack empty!");
		T dummy_value;
		return dummy_value;  //return arbitrary value
	}
}

template <class T>
T Stack<T>::topNoPop() const{
	assert(top>EmptyStack);
	if(!empty())
		return elements[top];
	else{
		msg("Stack empty!");
		T dummy_value;
		return dummy_value;
	}
}
template <class T>
bool Stack<T>::empty() const{
	return top<=EmptyStack;
}

template <class T>
bool Stack<T>::full() const{
	return top+1>=size;
}

template <class T>
ostream& operator<<(ostream& os,const Stack<T>& s)// 友元函数  重载运算符"<<"
{
	s.msg("Stack contents:");
	int t=s.top;
	while(t>s.EmptyStack)
		cout<<s.elements[t--]<<endl;
	return os;
}
int main()
{
	Stack<int> i_stack(4);
	int a;
	int i=0;
	while(i++<4)
	{
		cin>>a;
		i_stack.push(a);
	}
    cout<<i_stack.pop();    //弹出栈顶元素

	cout<<i_stack.topNoPop();
	

  return 0;


}