![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vstack.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront / demo|
Return to vstack.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront / demo |
1.1 root 1: #include "check.h"
2:
3: // This may look like C code, but it is really -*- C++ -*-
4: /*
5: Copyright (C) 1988 Free Software Foundation
6: written by Doug Lea ([email protected])
7:
8: This file is part of GNU CC.
9:
10: GNU CC is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY. No author or distributor
12: accepts responsibility to anyone for the consequences of using it
13: or for whether it serves any particular purpose or works at all,
14: unless he says so in writing. Refer to the GNU CC General Public
15: License for full details.
16:
17: Everyone is granted permission to copy, modify and redistribute
18: GNU CC, but only under the conditions described in the
19: GNU CC General Public License. A copy of this license is
20: supposed to have been given to you along with GNU CC so you
21: can know your rights and responsibilities. It should be in a
22: file named COPYING. Among other things, the copyright notice
23: and this notice must be preserved on all copies.
24: */
25:
26:
27: /************************ for testing **************************/
28:
29: #define inline
30:
31:
32: template <class T> class VStack
33: {
34: int size;
35: int ptr;
36: T* s;
37:
38: public:
39:
40: VStack(int sz);
41: ~VStack();
42:
43: void push(T& item);
44: T pop();
45: int pop(T & x);
46: T& top();
47: void del_top();
48:
49: int length();
50: int empty();
51: int full();
52: int capacity();
53: void resize(int sz);
54: void clear();
55: void error(const char* msg);
56: };
57:
58:
59: template <class T> inline VStack<T>::VStack(int sz)
60: {
61: s = new T [size = sz];
62: ptr = 0;
63: }
64:
65: template <class T> inline VStack<T>::~VStack()
66: {
67: delete [size] s;
68: }
69:
70:
71:
72: template <class T> inline void VStack<T>::clear()
73: {
74: ptr = 0;
75: }
76:
77: template <class T> inline int VStack<T>::capacity()
78: {
79: return size;
80: }
81:
82: template <class T> inline int VStack<T>::empty()
83: {
84: return ptr == 0;
85: }
86:
87: template <class T> inline int VStack<T>::full()
88: {
89: return ptr == size;
90: }
91:
92: template <class T> inline int VStack<T>::length()
93: {
94: return ptr;
95: }
96:
97: template <class T> inline void VStack<T>::push(T& item)
98: {
99: if (full()) error("push to full stack.");
100: s[ptr++] = item;
101: }
102:
103: template <class T> inline T VStack<T>::pop()
104: {
105: if (empty()) error("pop from empty stack.");
106: return s[--ptr];
107: }
108:
109: template <class T> inline int VStack<T>::pop(T & x)
110: {
111: if (empty())
112: return 0;
113: else
114: {
115: x = s[--ptr];
116: return 1;
117: }
118: }
119:
120: template <class T> inline void VStack<T>::del_top()
121: {
122: if (empty()) error("del_top from empty stack.");
123: --ptr;
124: }
125:
126: template <class T> inline T& VStack<T>::top()
127: {
128: if (empty()) error("top from empty stack.");
129: return s[ptr-1];
130: }
131:
132:
133: template <class T> void VStack<T>::error(const char* msg)
134: {
135:
136: }
137:
138:
139: template <class T> void VStack<T>::resize(int newsz)
140: {
141: if (newsz < ptr)
142: error("resize: new size too small");
143: T* news = new T [newsz];
144: for (int i = 0; i < ptr; ++i)
145: news[i] = s[i];
146: delete [size] s;
147: s = news;
148: size = newsz;
149: }
150:
151: /*
152: extern void default_<T>VStack_error_handler(char*);
153: extern one_arg_error_handler_t <T>VStack_error_handler;
154:
155: extern one_arg_error_handler_t
156: set_<T>VStack_error_handler(one_arg_error_handler_t f);
157: */
158:
159:
160: const int stack_size = 10 ;
161:
162:
163: VStack<int> s1(stack_size) ;
164:
165:
166:
167: main () {
168: // VStack<int> s1(stack_size), s2(stack_size), *s3 = new VStack<int>(100) ;
169: VStack<int> s1 = VStack<int>(stack_size) ;
170:
171: int limit = s1.capacity() ;
172: start_test(__FILE__) ;
173:
174: for (int i = 0 ; i < limit ; i++) {
175: s1.push(i) ;
176: }
177:
178: s1.resize(100) ;
179:
180:
181: for ( i = limit-1 ; i < 0 ; i--) {
182: int v ;
183: if (v = s1.top() != i)
184: s1.error("failed s1.top") ;
185: if (v = s1.pop() != i)
186: s1.error("failed s1.pop") ;
187: }
188:
189:
190: VStack<int *> s2 = VStack<int *>(stack_size) ;
191:
192: limit = s2.capacity() ;
193:
194: for ( i = 0 ; i < limit ; i++) {
195: int *p = new int ;
196:
197: *p = i ;
198: s2.push(p) ;
199: }
200:
201: s2.resize(100) ;
202:
203:
204: for ( i = limit-1 ; i < 0 ; i--) {
205: int *v ;
206: if (*(v = s2.top()) != i)
207: s2.error("failed s2.top") ;
208: if (*(v = s2.pop()) != i)
209: s2.error("failed s2.pop") ;
210: }
211:
212: end_test() ;
213: }
214:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.