IT++ Logo

stack.h

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

Generated on Sun Sep 14 18:52:34 2008 for IT++ by Doxygen 1.5.6