STL vector源码分析

vector

1.vector概述

vector和array非常类似，区别在于array是静态空间，一旦配置就不能改变了。空间不够之后需要换个更大的空间，这个工作需要有客户端自己打理。vector是动态空间，内部机制会自行扩充空间来容纳新元素。vector技术中关键部分在于，对大小的配置以及重新配置时数据移动的效率。

2.vector定义

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
  // requirements:

  __STL_CLASS_REQUIRES(_Tp, _Assignable);

private:
  typedef _Vector_base<_Tp, _Alloc> _Base;
public:
  typedef _Tp value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type* iterator;
  typedef const value_type* const_iterator;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
.
.
.}

这里从比<vector>更底层的<stl_vector.h>中摘出来的，其中需要注意的有两个地方：

1.__STL_DEFAULT_ALLOCATOR(_Tp)是SGI STL的空间配置器。

2.上面标红的是vector的迭代器，vector迭代器所需要的操作行为，入operator*、operator->、operator++、operator--、operator+、operator-、operator+=、operator-=，
vector支持随机存取，而普通指针也具备这样的能力，所以，vector<T>的迭代器就是T*，实质上是指针。

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
...
protected:
#ifdef __STL_HAS_NAMESPACES
  using _Base::_M_allocate;
  using _Base::_M_deallocate;
  using _Base::_M_start;
  using _Base::_M_finish;
  using _Base::_M_end_of_storage;
#endif /* __STL_HAS_NAMESPACES */
...
}

vector所采用的数据结构为线性连续空间，两个迭代器_M_start，_M_finish分别指向配置得来的连续空间中目前已被使用的范围，并以_M_end_of_storage指向整块连续空间（含备用空间）的尾端。利用这三个迭代器，可以轻松的提供首尾标识，大小，容量，空容器判断，注标（[ ]）运算子，最前端元素，最后端元素等等机能。

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
...
public:
  iterator begin() { return _M_start; }
  const_iterator begin() const { return _M_start; }
  iterator end() { return _M_finish; }
  const_iterator end() const { return _M_finish; }

  reverse_iterator rbegin()
    { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const
    { return const_reverse_iterator(end()); }
  reverse_iterator rend()
    { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const
    { return const_reverse_iterator(begin()); }

  size_type size() const
    { return size_type(end() - begin()); }
  size_type max_size() const
    { return size_type(-1) / sizeof(_Tp); }
  size_type capacity() const
    { return size_type(_M_end_of_storage - begin()); }
  bool empty() const
    { return begin() == end(); }

  reference operator[](size_type __n) { return *(begin() + __n); }
  const_reference operator[](size_type __n) const { return *(begin() + __n); }
...
}

3.vector的构造和内存管理

直接借用书中的测试代码，可以看到随着不同的操作，vector<int>的size和capacity一直在不停的变化之中，下面从源码之中来找出这些变化的本质。

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
...
  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }
...
}

拿其中一个构造函数为例，指定vector的大小n和初值value

  vector(size_type __n, const _Tp& __value,
         const allocator_type& __a = allocator_type()) 
    : _Base(__n, __a)
    { _M_finish = uninitialized_fill_n(_M_start, __n, __value); }

在<stl_uninitialized.h>中，定义了uninitialized_fill_n()

template <class _ForwardIter, class _Size, class _Tp>
inline _ForwardIter 
uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
{
  return __uninitialized_fill_n(__first, __n, __x, __VALUE_TYPE(__first));
}

调用__uninitialized_fill_n().

template <class _ForwardIter, class _Size, class _Tp, class _Tp1>
inline _ForwardIter 
__uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x, _Tp1*)
{
  typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
  return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
}

调用_uninitialized_fill_n_aux()会根据第一参数的型别特征决定使用算法fill_n()，或者是反复调用construct()来完成任务。

// Valid if copy construction is equivalent to assignment, and if the
// destructor is trivial.
template <class _ForwardIter, class _Tp>
inline void
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
                         const _Tp& __x, __true_type)
{
  fill(__first, __last, __x);
}

template <class _ForwardIter, class _Tp>
void
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
                         const _Tp& __x, __false_type)
{
  _ForwardIter __cur = __first;
  __STL_TRY {
    for ( ; __cur != __last; ++__cur)
      _Construct(&*__cur, __x);
  }
  __STL_UNWIND(_Destroy(__first, __cur));
}

使用push_back（）将新元素插入到vector尾端时，首先判断是否还有备用空间，有的话直接在备用空间上构造函数，同时调整迭代器_M_finish。

如果没有备用空间，就扩充空间（重新分配，移动数据，释放原空间）

  void push_back(const _Tp& __x) {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish, __x);
      ++_M_finish;
    }
    else
      _M_insert_aux(end(), __x);
  }

template <class _Tp, class _Alloc>
void 
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
{
  if (_M_finish != _M_end_of_storage) {//如果还有备用空间
    construct(_M_finish, *(_M_finish - 1));//在_M_finish地址上新建一个值为以前队尾元素的值。
    ++_M_finish;
    _Tp __x_copy = __x;
    copy_backward(__position, _M_finish - 2, _M_finish - 1);//将[__position, _M_finish - 2)之间的元素复制到以_M_finish - 1的地址上
    *__position = __x_copy;//插入的地方赋值
  }
  else {
    const size_type __old_size = size();
    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;//如果原有空间为0，则配置1，不为0，则配置原大小的两倍

    iterator __new_start = _M_allocate(__len);//重新再堆上申请内存
    iterator __new_finish = __new_start;
    __STL_TRY {
      __new_finish = uninitialized_copy(_M_start, __position, __new_start);//将原来的vector拷贝到新申请的地址
      construct(__new_finish, __x);//在vector的尾部添加继续你的元素
      ++__new_finish;
      __new_finish = uninitialized_copy(__position, _M_finish, __new_finish);//将安插点的原内容也拷贝过来
    }
    __STL_UNWIND((destroy(__new_start,__new_finish), 
                  _M_deallocate(__new_start,__len)));
    destroy(begin(), end());//析构并释放原vector
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __new_start;//调整迭代器，指向新的vector
    _M_finish = __new_finish;
    _M_end_of_storage = __new_start + __len;
  }
}

这一部分的代码还是很清晰的，配上书中的图很容易就可以理解。

4.vector的元素操作：pop_back，erase，clear，insert

pop_back相对容易

  void pop_back() {
    --_M_finish;
    destroy(_M_finish);
  }

erase（），清除[first, last)之间的所有元素或者指定位置的元素，配合书上的图应该很好理解。

  iterator erase(iterator __position) {
    if (__position + 1 != end())
      copy(__position + 1, _M_finish, __position);
    --_M_finish;
    destroy(_M_finish);
    return __position;
  }
  iterator erase(iterator __first, iterator __last) {
    iterator __i = copy(__last, _M_finish, __first);
    destroy(__i, _M_finish);
    _M_finish = _M_finish - (__last - __first);
    return __first;
  }

insert（）

这里就讨论一种： 

  void insert (iterator __pos, size_type __n, const _Tp& __x)
    { _M_fill_insert(__pos, __n, __x); }

插入过程可以分为两种情况，一种是备用空间大于要插入的元素，这种情况又分为插入的点之后现有元素个数大于新增元素个数和小于两种。

第二种情况是备用空间小于要插入的元素

1.备用空间大于新增元素个数

1）插入点之后的现有元素个数大于新增元素个数

给个图就能看的很明白

2）插入点之后的现有元素个数小于新增元素个数

2.备用空间小于新增元素个数

template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_insert(iterator __position, size_type __n, 
                                         const _Tp& __x)
{
  if (__n != 0) {
    if (size_type(_M_end_of_storage - _M_finish) >= __n) {//备用空间大于要插入的元素
      _Tp __x_copy = __x;
      const size_type __elems_after = _M_finish - __position;
      iterator __old_finish = _M_finish;
      if (__elems_after > __n) {//插入点之后的现有元素个数大于新增元素个数
        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
        _M_finish += __n;
        copy_backward(__position, __old_finish - __n, __old_finish);
        fill(__position, __position + __n, __x_copy);
      }
      else {//插入点之后的现有元素个数小于于新增元素个数

        uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);
        _M_finish += __n - __elems_after;
        uninitialized_copy(__position, __old_finish, _M_finish);
        _M_finish += __elems_after;
        fill(__position, __old_finish, __x_copy);
      }
    }
    else {//备用空间小于要插入的元素
      const size_type __old_size = size();        
      const size_type __len = __old_size + max(__old_size, __n);
      iterator __new_start = _M_allocate(__len);
      iterator __new_finish = __new_start;
      __STL_TRY {
        __new_finish = uninitialized_copy(_M_start, __position, __new_start);
        __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
        __new_finish
          = uninitialized_copy(__position, _M_finish, __new_finish);
      }
      __STL_UNWIND((destroy(__new_start,__new_finish), 
                    _M_deallocate(__new_start,__len)));
      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __new_start;
      _M_finish = __new_finish;
      _M_end_of_storage = __new_start + __len;
    }
  }
}

最后需要注意的地方是，vector中的迭代器在经过类似push_back、insert之后可能不在指向之前的值，因为其本质为指针，如果在容量不够的情况下扩充内容之后，之前的迭代器有可能全部失效。