IT++ Logo Newcom Logo

stack.h

Go to the documentation of this file.
00001 
00039 #ifndef STACK_H
00040 #define STACK_H
00041 
00042 #include <itpp/base/itassert.h>
00043 
00044 
00045 namespace itpp {
00046 
00068   template<class T>
00069     class Stack {
00070     public:
00072     Stack();
00074     Stack(int n);
00076     Stack(const Stack<T> &s);
00078     virtual ~Stack();
00079 
00081     T pop();
00083     T peek() const;
00085     void push(T v);
00087     void clear();
00088 
00090     void operator=(const Stack<T> &s);
00091 
00093     int size() const { return ndata; }
00095     int no_elements() const { return valptr; }
00097     void set_size(int n, bool copy=false);
00098 
00099     private:
00100     int valptr;
00101     int ndata;
00102     T *data;
00103 
00104     private:
00105     void alloc(int n);
00106     void free();
00107   };
00108 
00109   // --------------------------- Implementation starts here ----------------------------------
00110 
00111   template<class T>
00112     Stack<T>::Stack()
00113     {
00114       data = 0;
00115       ndata = 0;
00116       valptr = 0;
00117     }
00118 
00119   template<class T>
00120     Stack<T>::Stack(int n)
00121     {
00122       alloc(n);
00123       valptr=0;
00124     }
00125 
00126   template<class T>
00127     Stack<T>::Stack(const Stack<T> &s)
00128     {
00129       data=NULL;
00130       ndata=0;
00131       valptr=s.valptr;
00132       alloc(s.ndata);
00133       for (int i=0; i<s.ndata; i++)
00134         data[i] = s.data[i];
00135     }
00136 
00137   template<class T>
00138     Stack<T>::~Stack()
00139     {
00140       free();
00141     }
00142 
00143   template <class T>
00144     T Stack<T>::pop()
00145     {
00146       it_error_if(valptr==0,"Stack<T>::pop: Empty stack");
00147       valptr--;
00148       return data[valptr];
00149     }
00150 
00151   template <class T>
00152     T Stack<T>::peek() const
00153     {
00154       it_error_if(valptr==0,"Stack<T>::peek: Empty stack");
00155       return data[valptr-1];
00156     }
00157 
00158   template <class T>
00159     void Stack<T>::push(T v)
00160     {
00161       it_error_if(valptr>=ndata,"Stack<T>::push: Full stack");
00162       data[valptr]=v;
00163       valptr++;
00164     }
00165 
00166   template <class T>
00167     void Stack<T>::clear()
00168     {
00169       valptr=0;
00170     }
00171 
00172   template<class T>
00173     void Stack<T>::alloc(int n)
00174     {
00175       if (n == 0) {
00176         data = NULL;
00177         ndata = 0;
00178       }
00179       else {
00180         data = new T[n];
00181         it_assert1(data!=0, "Out of memory in Stack::alloc");
00182       }
00183       ndata = n;
00184     }
00185 
00186   template<class T>
00187     void Stack<T>::free()
00188     {
00189 
00190       delete [] data;
00191 
00192       data = 0;
00193       ndata = 0;
00194     }
00195 
00196   template<class T>
00197     void Stack<T>::operator=(const Stack<T> &s)
00198     {
00199       set_size(s.ndata);
00200       for (int i=0; i<ndata; i++)
00201         data[i] = s.data[i];
00202       valptr=0;
00203     }
00204 
00205   template<class T>
00206     void Stack<T>::set_size(int sz, bool copy)
00207     {
00208       int i, min;
00209       T *tmp;
00210 
00211       if (ndata == sz)
00212         return;
00213 
00214       if (copy) {
00215         tmp = data;
00216         min = ndata < sz ? ndata : sz;
00217         alloc(sz);
00218         for (i=0; i<min; i++)
00219           data[i] = tmp[i];
00220         delete [] tmp;
00221       } else {
00222         free();
00223         alloc(sz);
00224       }
00225       ndata = sz;
00226     }
00227 
00228 } // namespace itpp
00229 
00230 #endif // #ifndef STACK_H
SourceForge Logo

Generated on Fri Jan 11 08:51:37 2008 for IT++ by Doxygen 1.3.9.1