Heidelberg Educational Numerics Library Version 0.24 (from 9 September 2011)

src/array.hh

Go to the documentation of this file.
00001 // -*- tab-width: 4; indent-tabs-mode: nil -*-
00002 #ifndef HDNUM_ARRAY_HH
00003 #define HDNUM_ARRAY_HH
00004 
00009 namespace hdnum {
00010 
00016   template<class T>
00017   class Array {
00018   public:
00019 
00021         typedef T value_type;
00022 
00024         typedef value_type& reference;
00025 
00027         typedef const value_type& const_reference;
00028 
00030         typedef std::size_t size_type;
00031 
00033         typedef std::ptrdiff_t difference_type;
00034 
00036         Array ()
00037         {
00038           n = 0;
00039           p = 0;
00040         }
00041 
00043         Array (size_type _n) : n(_n)
00044         {
00045           if (n>0) 
00046                 p = new T[n];
00047           else
00048                 {
00049                   n = 0;
00050                   p = 0;
00051                 }
00052         }
00053 
00055         Array (size_type _n, const T& _t) : n(_n)
00056         {
00057           if (n>0) 
00058                 p = new T[n];
00059           else
00060                 {
00061                   n = 0;
00062                   p = 0;
00063                 }
00064           for (size_type i=0; i<n; i++) p[i] = _t;
00065         }
00066 
00068         Array (const Array& a) 
00069         {
00070           // allocate memory with same size as a
00071           n = a.n;
00072           if (n>0) 
00073                 p = new T[n];
00074           else
00075                 {
00076                   n = 0;
00077                   p = 0;
00078                 }
00079 
00080           // and copy elements
00081           for (size_type i=0; i<n; i++) p[i]=a.p[i];
00082         }
00083 
00085         ~Array () 
00086         { 
00087           if (n>0) delete [] p; 
00088         }
00089 
00091         void resize (size_type _n)
00092         {
00093           if (n==_n) return;
00094           if (n>0) delete [] p; 
00095           n = _n;
00096           if (n>0) 
00097                 p = new T[n];
00098           else
00099                 {
00100                   n = 0;
00101                   p = 0;
00102                 }
00103         }
00104 
00106         void resize (size_type _n, const T& _t)
00107         {
00108           if (n==_n) return;
00109           if (n>0) delete [] p; 
00110           n = _n;
00111           if (n>0) 
00112                 p = new T[n];
00113           else
00114                 {
00115                   n = 0;
00116                   p = 0;
00117                 }
00118           for (size_type i=0; i<n; i++) p[i] = _t;
00119         }
00120 
00122         Array& operator= (const Array& a)
00123         {
00124           if (&a!=this) // check if this and a are different objects
00125                 {
00126                   // adjust size of array
00127                   if (n!=a.n) // check if size is different
00128                         {
00129                           if (n>0) delete [] p; // delete old memory
00130                           n = a.n;
00131                           if (n>0) 
00132                                 p = new T[n];
00133                           else
00134                                 {
00135                                   n = 0;
00136                                   p = 0;
00137                                 }
00138                         }
00139                   // copy data
00140                   for (size_type i=0; i<this->n; i++) p[i]=a.p[i];
00141                 }
00142           return *this;
00143         }
00144 
00146         reference operator[] (size_type i)
00147         {
00148           return p[i];
00149         }
00150 
00152         const_reference operator[] (size_type i) const
00153         {
00154           return p[i];
00155         }
00156 
00158         size_type size () const
00159         {
00160           return n;
00161         }
00162 
00163   private:
00164         size_type n;
00165         T* p;
00166   };
00167 
00168 } // namespace hdnum
00169 
00170 #endif