【C++】STL---vector底层实现

成员变量

class vector
{
 private:

     iterator _start; // 指向数据块的开始

     iterator _finish; // 指向有效数据的尾

     iterator _endOfStorage; // 指向存储容量的尾
};

构造函数

无参构造

   vector()
        {
            T* v=new T[2];
            _start = _finish = v;
            _endOfStorage=v+2;
        }

构造前n个数

  vector(int n, const T& value = T())
{
   _start=_finish = new T[n];
   while (n--)
   {
       *_finish = value;
       _finish++;
   }
   _endOfStorage = _finish;

}

迭代器区间构造

    template<class InputIterator>

  vector(InputIterator first, InputIterator last)
  {
      _start = _finish = new T[last-first];
      while (first != last)
      {
          *_finish = *first;
          _finish++;
          first++;
      }
      _endOfStorage = _finish;
}

拷贝构造

  vector(const vector<T>& v)
  {
      _finish=_start = new T[v.capacity()];
   // memcpy(begin(), v.begin(), v.size());          浅拷贝（错误写法）
      for (auto e : v)
      {
          *_finish = T(e);
          _finish++;
      }
          _endOfStorage = _start + v.capacity();
  }

析构函数

 ~vector()
{
    delete[] _start;
    _start = _finish = _endOfStorage = nullptr;
}

迭代器

typedef T* iterator;

typedef const T* const_iterator;

   iterator begin()const
{
   return _start;
}

iterator end()const
{
   return _finish;
   }

const_iterator cbegin()const
{
   //const iterater
   return  _start;
   }

const_iterator cend() const
{
   return  _finish;
   }

运算符重载

赋值重载

 void clean()
{
   _finish = _start;
}
void swap(vector<T> v)
{
   std::swap(_start, v._start);
   std::swap(_finish, v._finish);
   std::swap(_endOfStorage, v._endOfStorage);
}
vector<T>& operator= (vector<T> v)
{
   clean();
   swap(v);
       return *this;
}

下标方括号**[]**重载

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

                 const T& operator[](size_t pos)const
                 {
                     return _start[pos];
                 }

容量相关操作

reserve

注意区分深浅拷贝

 void reserve(size_t n)
 {
     if (n > capacity())
     {
         int old_size = size();
        T* tmp = new T[2 * capacity()];
        T* cur = tmp;
       //  memcpy(tmp, _start, size() );             浅拷贝（错误写法）
        for (auto e : *this)
        {
            *tmp = e;                                          //深拷贝
            tmp++;
        }
         delete[]  _start;
         _start =cur;
         tmp = nullptr;
         _finish = _start + old_size;
         _endOfStorage = _start+ 2 * capacity();
     }
 }

risize

  void resize(size_t n, const T& value = T())
 {
     if (n < size())
     {
         _finish = _start + n;
     }
     if (n >= size())
     {
         reserve(n);
         size_t count = n - size();
         while (count--)
         {
             *_finish = value;
             _finish++;
         }
     }
 }

size()

  size_t  size() const
{
    return  _finish-_start;
}

capacity()

  size_t capacity() const
  {
      return _endOfStorage - _start;
  }
  

尾插尾删函数

  void push_back(const T& x)
 {
     reserve(size() + 1);
     *(_finish) = x;
     _finish++;
 }
 void pop_back()
 {
     _finish--;
 }

insert在指定位置插入函数

注意如果扩容要更新pos的值

  iterator insert(iterator pos, const T& x)
   {
       if(_finish==_endOfStorage)
       {
           size_t len = pos - _start;
           reserve(capacity() == 0 ? 4 : capacity() * 2);//若充满则扩容
           pos = _start + len;//更新pos
       }
       //把从pos位置开始，往后的sizeof(T) * (_finish - pos)个元素复制到pos+1位置
       memmove(pos + 1, pos, sizeof(T) * (_finish - pos));
       *pos = x;//挪动之后再把x放到pos位置
       ++_finish;
       return pos;
   }