vector 接口模拟实现

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;
    }