数据结构--变长数组

刚发现，以前用vector觉得挺简单的，自己实现一下才知道这么麻烦。真是佩服那些C++大师，写出这么好的东西。

这算是一个简易的vector吧，之所以说它简易，并不是因为功能少，而是实现的复杂度远远不及std::vector

但基本原理是一样的

 

  1 #pragma once
  2 
  3 const int INIT_ARRAY_SIZE = 10;
  4 template<typename T>
  5 class Array
  6 {
  7 public:
  8     struct Iterator    {
  9         
 10         Iterator(T* ptr):m_ptr(ptr){}
 11 
 12         T& operator*()
 13         {
 14             return (*m_ptr);
 15         }
 16 
 17         T* operator->()
 18         {
 19             return (&**this);
 20         }
 21 
 22         Iterator& operator++()
 23         {
 24             ++m_ptr;
 25             return *this;
 26         }
 27         Iterator operator++(int)
 28         {
 29             Iterator temp = *this;
 30             ++(*this);
 31             return temp;
 32         }
 33 
 34         Iterator& operator--()
 35         {
 36             --m_ptr;
 37             return *this;
 38         }
 39         Iterator operator--(int)
 40         {
 41             Iterator temp = *this;
 42             --(*this);
 43             return temp;
 44         }
 45 
 46         bool operator!=(const Iterator &it)
 47         {
 48             return m_ptr != it.m_ptr;
 49         }
 50 
 51         bool operator==(const Iterator &it)
 52         {
 53             return m_ptr == it.m_ptr;
 54         }
 55 
 56         bool operator<(const Iterator &it)
 57         {
 58             return m_ptr<it.m_ptr;
 59         }
 60 
 61         Iterator operator+(size_t off) const
 62         {
 63             Iterator tmp = *this;
 64             tmp.m_ptr+=off;
 65             return tmp;
 66         }
 67 
 68 
 69 
 70         Iterator operator-(size_t off)
 71         {
 72             Iterator tmp = *this;
 73             tmp.m_ptr-=off;
 74             return tmp;
 75         }
 76 
 77         size_t operator-(const Iterator& it)
 78         {
 79             return m_ptr - it.m_ptr;
 80         }
 81 
 82 
 83         T* m_ptr;
 84     };
 85     Array()
 86         : m_head(new T[INIT_ARRAY_SIZE]),
 87           m_last(m_head),
 88           m_end(m_head+INIT_ARRAY_SIZE-1)
 89     {}
 90 
 91     Array(size_t t)
 92         : m_head(new T[INIT_ARRAY_SIZE<t ? t : INIT_ARRAY_SIZE]),
 93           m_last(m_head+t),
 94           m_end(m_head+(INIT_ARRAY_SIZE<t ? t-1 : INIT_ARRAY_SIZE-1))
 95     {}
 96 
 97     T& operator[](size_t t)
 98     {
 99         return *(m_head+t);
     }
 
     size_t size()
     {
         return m_head == 0 ? 0 : m_last-m_head/* / sizeof(T)*/;
     }
 
     
 
     void push_back(const T& data)
     {
         size_t s;
         s = size();
         s = capacity();
         if(size() <capacity())
         {
             m_head[size()] = data;
             m_last++;
         }
         else//需要扩充长度
         {
             insert(end(), data);
         }
     }
 
     Iterator insert(Iterator _Where, const T& data)
     {
         size_t off = _Where - begin();
         _Insert(_Where, 1, data);
         return begin()+off;
     }
 
     Iterator begin()
     {
         return m_head;
     }
 
     Iterator end()
     {
         return m_last;
     }
 
     bool empty()
     {
         return size() == 0;
     }
 
     void remove(Iterator _Where)
     {
         if(empty())
         {
             return;
         }
         
         size_t off = _Where-begin();
 
         
 
         _move(_Where+1, end(), m_head+off);
         m_last--;
     }
 
 private:
 
 
     size_t capacity()
     {
         return m_head == 0 ? 0 : m_end-m_head;
     }
 
     void _Insert(Iterator _Where, size_t nCount, const T& data)
     {
 
         if(capacity() - size() < nCount)
         {
 
             size_t oldSize = size();
             size_t Capacity = capacity();
             size_t newSize = (Capacity+1)*1.5;
             if (newSize < size() + nCount)
             {
                 newSize = size() + nCount;
             }
 
             T* temp = new T[newSize];
 
             T* t = temp;
             Iterator it = begin();
             t = _move(begin(), _Where, t);
 
             t = _fill(t, t+nCount, data);
 
             _move(_Where, end(), t);
 
             delete[] m_head;
     
             m_head = temp;
             m_last = m_head + oldSize + nCount;
             m_end = temp + newSize - 1;
 
         }
         else if(end() - _Where < nCount)
         {
             T* p = _move(_Where, m_last, _Where.m_ptr+nCount);
         
 
             _fill(_Where, _Where+nCount, data);
             m_last+=nCount;
         }
         else
         {
             T* oldEnd = m_last;
         
 
             _copy_backward(_Where, oldEnd, oldEnd+nCount);
 
 
             
             _fill(_Where, _Where+nCount, data);
             m_last += nCount;
 
         }
     }
 
     T* _move(Iterator _First, Iterator _Last, T* p)
     {
         for(; _First != _Last; )
         {
             *p++= *_First++;
             
         }
 
         return p;
     }
 
     void _copy_backward(Iterator _First, Iterator _Last, T* p)
     {
         for(; !(_Last < _First); )
         {
             *p-- = *_Last--;
         }
     }
 
     T* _fill(Iterator _First, Iterator _Last, const T& data)
     {
         for(; _First != _Last; )
         {
             *_First++ = data;
         }
 
         return _First.m_ptr;
     }
 
     T* m_head;
     T* m_last;
     T* m_end;
 };