堆栈模板

#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;

}