链栈

在不用容器的基础上模拟了一个链栈：

Code:

1. #include <iostream>   
2. #include <assert.h>   
3. #include <string>   
4. using namespace std;   
5. template <typename T>   
6. class Node   
7. {   
8. public:   
9.     Node():next(0){}   
10.     Node(const T& val):elem(val),next(0){}   
11. //private:   
12.     T elem;   
13.     Node *next;   
14. };   
15. template <typename T>   
16. class stack   
17. {   
18. public:   
19.     typedef T value_type;   
20.     typedef size_t size_type;   
21.     stack():Top(0),Base(0),Size(0){}   
22.     bool empty()   
23.     {   
24.         return (Top == 0);   
25.     }   
26.     size_type size();   
27.     value_type& top();   
28.     const value_type& top() const;   
29.     void push(const value_type& elem);   
30.     void pop();   
31.     bool Eq(const stack<T>& rhs)const;   
32.     bool Lt(const stack<T>& rhs)const;   
33. protected:   
34.     Node<T> *Top; //栈顶指针,指向最后一个节点。   
35.     Node<T> *Base; //栈底指针，指向第一个节点。   
36.     size_t Size; //栈的大小   
37. };   
38. template <typename T>   
39. typename stack<T>::size_type stack<T>::size()   
40. {   
41.     return Size;   
42. }   
43. template <typename T>   
44. typename stack<T>::value_type& stack<T>::top()   
45. {   
46.     if (empty())   
47.     {   
48.         throw out_of_range("stack<>::top------stack empty.");   
49.     }   
50.     return Top->elem;   
51. }   
52. template <typename T>   
53. const typename stack<T>::value_type& stack<T>::top() const  
54. {   
55.     if (empty())   
56.     {   
57.         throw out_of_range("stack<>::top------stack empty.");   
58.     }   
59.     return Top->elem;   
60. }   
61. template <typename T>   
62. void stack<T>::push(const value_type& elem)   
63. {   
64.     Node<T> *p = new Node<T>(elem);   
65.     if (empty())   
66.     {   
67.         Top = p;   
68.         Base = Top;   
69.     }   
70.     else  
71.     {   
72.         Top->next = p;   
73.     }   
74.     p->next = NULL;   
75.     Top = p;   
76.     ++Size;   
77. }   
78. template <typename T>   
79. void stack<T>::pop()   
80. {   
81.     if (empty())   
82.     {   
83.         throw out_of_range("stack<>::pop------stack empty.");   
84.     }   
85.     Node<T> *q = Base;   
86.     while (q->next != Top)   
87.     {   
88.         q = q->next;   
89.     }   
90.     Node<T> *h = Top;   
91.     Top = q;   
92.     q->next = NULL;   
93.     delete h;   
94.     --Size;   
95. }   
96. template <typename T>   
97. bool stack<T>::Eq(const stack<T>& rhs)const  
98. {   
99.     if (Size != rhs.Size)   
100.     {   
101.         return false;   
102.     }   
103.     else  
104.     {   
105.         Node<T> *p = Base;   
106.         Node<T> *q = rhs.Base;   
107.         while ((p->elem == q->elem) && (p != Top))   
108.         {   
109.             p = p->next;   
110.             q = q->next;   
111.         }   
112.         if ((p == Top) && (q = rhs.Top) && (p->elem == q->elem))   
113.         {   
114.             return true;   
115.         }   
116.         return false;   
117.     }   
118. }   
119. template <typename T>   
120. bool stack<T>::Lt(const stack<T>& rhs)const  
121. {   
122.     if (Size != rhs.Size)   
123.     {   
124.         return (lhs.Size < rhs.Size);   
125.     }   
126.     else  
127.     {   
128.         Node<T> *p = Base;   
129.         Node<T> *q = rhs.Base;   
130.         while (p->elem == q->elem)   
131.         {   
132.             ++p;   
133.             ++q;   
134.         }   
135.         if ((p == Top) && (q = rhs.Top) )   
136.         {   
137.             return false;   
138.         }   
139.         else if (p == Top)   
140.         {   
141.             return true;   
142.         }   
143.         else if(q == rhs.Top)   
144.         {   
145.             return false;   
146.         }   
147.         return (elem < rhs.elem);   
148.     }   
149. }   
150. template <typename T>   
151. bool operator == (const stack<T>& lhs,const stack<T>& rhs)   
152. {   
153.     return lhs.Eq(rhs);   
154. }   
155. template <typename T>   
156. inline bool operator != (const stack<T>& lhs,const stack<T>& rhs)   
157. {   
158.     return !(lhs == rhs);   
159. }   
160. template <typename T>   
161. bool operator < (const stack<T>& lhs,const stack<T>& rhs)   
162. {   
163.     return lhs.Lt(rhs);   
164. }   
165. template <typename T>   
166. bool operator > (const stack<T>& lhs,const stack<T>& rhs)   
167. {   
168.     return (rhs < lhs);   
169. }   
170. template <typename T>   
171. bool operator <= (const stack<T>& lhs,const stack<T>& rhs)   
172. {   
173.     return !(lhs > rhs);   
174. }   
175. template <typename T>   
176. bool operator >= (const stack<T>& lhs,const stack<T>& rhs)   
177. {   
178.     return !(lhs < rhs);   
179. }   
180. int main()   
181. {   
182.     try  
183.     {   
184.         stack<int> mystack1,mystack3;   
185.         mystack1.push(3);   
186.         assert(mystack1 != mystack3);   
187.         cout << mystack1.top() << endl;   
188.         mystack1.push(4);   
189.         cout << mystack1.top() << endl;   
190.         mystack1.push(5);   
191.         cout << mystack1.top() << endl;   
192.         mystack1.pop();   
193.         cout << mystack1.top() << endl;   
194.         mystack1.push(6);   
195.         cout << mystack1.top() << endl;   
196.         cout << mystack1.size() << endl;   
197.         stack<string> mystack2;   
198.         mystack2.push("hello");   
199.         cout << mystack2.top() << endl;   
200.         mystack2.push("world");   
201.         cout << mystack2.top() << endl;   
202.         cout << mystack2.size() << endl;   
203.        
204.   
205.     }   
206.     catch(const exception& ex)   
207.     {   
208.         cerr << ex.what() << endl;   
209.     }   
210.     system("pause");   
211.     return 0;   
212. }