vector的使用与模拟实现

vector的使用与模拟实现

vector的定义

vector是一个封装了动态大小数组的顺序容器，它能够存放各种类型的对象。

vector的基本函数使用

1 push_back(const T& x)

向容器尾部插入值为x的元素

2 empty()

判断容器是否为空

3 size()

返回容器的元素个数

4 begin()

返回起始位置迭代器，指向头部元素

5 end()

返回结束位置迭代器，指向尾部元素的下一个位置

6 capacity()

返回容器的容量

7 reserve(size_t n)

将容器扩容到能容纳n个元素，若n<capacity，则不扩容

8 resize(size_t n, const T& value = T())

将容器的容量改变成n个元素，可以扩容也可以缩容，若扩容则将第二个参数的值填充到扩容的元素中

9 operator[](size_t pos)

重载[]运算符，使vector能够支持[]访问

10 insert(iterator pos, const T& x)

在pos位置插入一个值为x的元素

11 erase(Iterator pos)

删除pos位置的元素

vector的模拟实现

template<class T>
class vector
{
public:
    // Vector的迭代器是一个原生指针
    typedef T* iterator；
    typedef const T* const_iterator；
    iterator begin()
    {
      return _start;
    }
    iterator end()
    {
      return _finish;
    }
    const_iterator cbegin()const
    {
      return _start;
    }
    const_iterator cend() const
    {
      return _finish;
    }
    vector(): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr)
    {}
    vector(int n, const T& value = T())
      : _start(nullptr), _finish(nullptr),_endOfStorage(nullptr)
    {
      reserve(n);
      while (n--)
      {
        push_back(value);
      }
    }
    template<class InputIterator>
    vector(InputIterator first, InputIterator last)
    {
      reserve(last - first);
      while (first != last)
      {
        push_back(*first);
        ++first;
      }
    }
    vector(const vector<T>& v)
      : _start(nullptr), _finish(nullptr), _endOfStorage(nullptr)
    {
      reserve(v.capacity());
      iterator it = begin();
      const_iterator vit = v.cbegin();
      while (vit != v.cend())
      {
      	*it++ = *vit++;
      }
      _finish = _start + v.size();
      _endOfStorage = _start + v.capacity();
    }
    vector<T>& operator= (vector<T> v)
    {
      swap(v);
      return *this;
    }
    ~vector()
    {
      delete[] _start;
      _start = _finish = _endOfStorage = nullptr;
    }
    size_t size() const 
    {
      return _finish - _start;
    }
    size_t capacity() const
    {
      return _endOfStorage - _start;
    }
    void reserve(size_t n)
    {
      if (n > capacity())
      {
        size_t oldSize = size();
        T* tmp = new T[n];
        if (_start)
        {
          for (size_t i = 0; i < oldSize; ++i)
          tmp[i] = _start[i];
        }
        _start = tmp;
        _finish = _start + size;
        _endOfStorage = _start + n;
      }
    }
    void resize(size_t n, const T& value = T())
    {
      // 1.如果n小于当前的size，则数据个数缩小到n
      if (n <= size())
      {
        _finish = _start + n;
        return;
      }
      // 2.空间不够则增容
      if (n > capacity())
      	reserve(n);
      // 3.将size扩大到n
      iterator it = _finish;
      iterator _finish = _start + n;
      while (it != _finish)
      {
        *it = value;
        ++it;
      }
    }
    T& operator[](size_t pos)
    {
      return _start[pos];
    }
    const T& operator[](size_t pos)const
    {
      return _start[pos];
    }
    void push_back(const T& x)
    {
      insert(end(), x);
    }
    void pop_back()
    {
      erase(--end());
    }
    void swap(vector<T>& v)
    {
      swap(_start, v._start);
      swap(_finish, v._finish);
      swap(_endOfStorage, v._endOfStorage);
    }
    iterator insert(iterator pos, const T& x)
    {
      assert(pos <= _finish);
      // 空间不够先进行增容
      if (_finish == _endOfStorage)
      {
        size_t size = size();
        size_t newCapacity = (0 == capacity())? 1 : capacity() * 2;
        reserve(newCapacity);
        // 如果发生了增容，需要重置pos
        pos = _start + size;
      }
      iterator end = _finish - 1;
      while (end >= pos)
      {
        *(end + 1) = *end;
        --end;
      }
      *pos = x;
      ++_finish;
      return pos;
    }
    // 返回删除数据的下一个数据
	// 方便解决:一边遍历一边删除的迭代器失效问题
    iterator erase(Iterator pos)
    {
      // 挪动数据进行删除
      iterator begin = pos + 1;
      while (begin != _finish) 
      {
        *(begin - 1) = *begin;
        ++begin;
      }
      --_finish;
      return pos;
    }
private:
    iterator _start; // 指向数据块的开始
    iterator _finish; // 指向有效数据的尾
    iterator _endOfStorage; // 指向存储容量的尾
  };