vector 介面模擬實現

vector部分常用成員函式的模擬實現

private:  //成員資料
       T* _start;  //指向開頭地址
       T* _finish;//指向最後有效長度的後一個地址
       T* _endofstorage; //指向開闢容量的後一個
       

建構函式

無參構造

Vector()  //無參構造
         :_start(nullptr),
          _finish(nullptr),
          _endofstorage(nullptr)
     {}

指定容量，與初始化值

指定vector的長度，和初始化值

  Vector(size_t n,const T value= T())//使用元素個數和數值進行初始化
         :_start(nullptr),
         _finish(nullptr),
         _endofstorage(nullptr)
       {
          Reserve(n);//開闢n個空間

          while(n--)
          {
            Push_back(value);
          }
       }

使用迭代區間為引數

初始化時使用迭代器的區間進行初始化

      //使用任意模板，可以使引數為任意容器的迭代器，如果使用iterator的話只能為vector的容器
         template<class tempIterator>
         Vector(tempIterator first,tempIterator last)
        {
            Reserve(last-first);//開闢一個迭代器兩端大小的空間//
            while(first!=last)
            {
              Push_back(*first);
              first++;
            }
  
        }

 

拷貝構造

   Vector( Vector<T>& v)
         :_start(nullptr),
          _finish(nullptr),
          _endofstorage(nullptr)
       {
  
         Reserve(v.Capacity()); //開闢與所拷貝的的物件同樣大小的空間
 
         Iterator it=v.begin();
         Iterator it1=begin();
         while(it!=v.end())
         {
           *it1=*it;
         }//使用迭代器進行拷貝,要進行深拷貝

         _finish=_start+v.Size();
         _endofstorage=_start+v.Capacity();

       }

Swap

交換函式

       void Swap(Vector<T>& v)
       {
         swap(_start,v._start);
         swap(_finish,v._finish);
         swap(_endofstorage,v._endofstorage);
       
       }

賦值運算子過載

       Vector<T> operator=(Vector<T> v)
       {
         this->Swap(v);  //和臨時物件交換，將臨時物件的空間拿過來用
         return *this;
       }

[]過載

      T operator[](size_t i)
      {
        return _start[i];
      }

容量

reserve()

設定vector的容量，增容

 void Reserve(size_t n)
      {
        if(n>Capacity())
        {
          T* tmp=new T[n];//開闢新的空間
          size_t size=Size();
         if(_start){
          for(int i=0;i<Size();i++)
               tmp[i]=_start[i];  // 交換進行深拷貝(當T為string時需要深拷貝)
         }
          _start=tmp;       //此時為tmp開闢的空間  
          _finish=_start+size;
          _endofstorage=_start+n;
    
        }
      }

resize

設定有效長度，當小於當前有效長度時，縮短有效長度，當超出當前有效的長度，但小於容量，將超出部分置位0。
當超出容量時，增容到所給引數位置

 void Resize(size_t n, T value= T())//預設預設初始化
      {
         if(n<=Size())
         {
           _finish=_start+n;
         }
         else if(n <= Capacity() && n > Size())
         {
           n -= Size();
           while(n--)
           {
             Push_back(value);
             _finish++;
           }           
         }
         else if(n > Capacity())
        {
          Reserve(n);
         while(_finish != _start+n)
         {
           Push_back(value);
         }
        
        }
      }

size()

返回當前容器中的有效長度

 size_t Size()
      {
        return _finish-_start;
      }

Capacity()

返回vector的容量

size_t Capacity()
      {
        return _endofstorage-_start;
      }

empty()

判斷是否為空

bool Empty()
      {
        return Size()==0?true:false;
      }

erase

刪除一個值，傳入迭代器的位置，刪除後可能會導致迭代器失效

   Iterator Erase(Iterator pos)
      {
        if(pos+1!=end())
        {
          Iterator begin=pos+1;
          while(begin!=_finish-1)
          {
            *(begin-1)=*begin;
              begin++;
          }

        }
        --_finish;

        return pos;
      }
      //返回刪除的數的數的迭代器

迭代器

       typedef T* Iterator; //非const迭代器
       typedef const T* constiterator; //const 迭代器
      
       Iterator begin()
       {
         return _start;
       }

       Iterator end()
       {
         return _finish;
       }
       
       constiterator cbegin()
       {
         return _start;
       }
       
       constiterator cend()
       { 
         return _finish; 
       }

insert

在迭代器位置之前插入一個元素，會導致

    Iterator Insert(Iterator pos,T value)
    {
      assert(pos<=_finish);
      
      size_t offset=pos-_start;//增容更換空間後pos處的迭代器會失效，記錄其偏移量

      if(_finish == _endofstorage)
      {
        size_t newCapacity = Capacity()==0?2:2*Capacity(); //防止第一次為空
        Reserve(newCapacity);
      }

      pos = begin() + offset;
      Iterator end =this->end();
      while(end != pos)
      {
        *end = *(end-1);
         end--;
      }

      *pos = value;
      _finish++;
      return pos;

    }

push_back

尾插

    void Push_back(T v)
    {
      Insert(_finish,v);
    }

pop_back

尾刪

    void Pop_back()
    {
      Erase(end()-1);
    }

列印函式（自定義）

    void Print()
    {
      for(int i=0;i<Size();i++)
      cout<<_start[i]<<" ";
      cout<<endl;
    }