STL学习（自学手册+源码分析）之vector

1.1容器vector

1.1.1主体实现：

template <class _Tp, class _Alloc = allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
  // requirements:

  __STL_CLASS_REQUIRES(_Tp, _Assignable);

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

  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  typedef reverse_iterator<const_iterator, value_type, const_reference, 
                           difference_type>  const_reverse_iterator;
  typedef reverse_iterator<iterator, value_type, reference, difference_type>
          reverse_iterator;
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

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 */

protected:
  void _M_insert_aux(iterator __position, const _Tp& __x);//辅助函数帮助扩容
  void _M_insert_aux(iterator __position);

public:
  iterator begin() { return iterator (_M_start); }
  const_iterator begin() const
    { return const_iterator (_M_start); }
  iterator end() { return iterator (_M_finish); }
  const_iterator end() const { return const_iterator (_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(const_iterator(_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); }
  
  reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(end() - 1); }
  const_reference back() const { return *(end() - 1); }

1.1.2 扩容辅助函数_M_insert_aux( )实现

template <class _Tp, class _Alloc>
void 
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
{
  if (_M_finish != _M_end_of_storage) {//因为不止vector调用该函数，进入之后需要再次判断是否还有空间
    construct(_M_finish, *(_M_finish - 1));//在备用空间起始处构建一个元素，并以vector最后一个元素值为其初始值
    ++_M_finish;//调整水位
    _Tp __x_copy = __x;
    copy_backward(__position, iterator(_M_finish - 2), iterator(_M_finish- 1));
    *__position = __x_copy;
  }
  else {//已无备用空间
    const size_type __old_size = size();//备份原有空间
    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;//最初的vector有可能是0，否则乘以2,扩容
    //以上的前半段用来放置原有数据 后半段准备用来放置新数据
    iterator __new_start(_M_allocate(__len));
    iterator __new_finish(__new_start);
    __STL_TRY {
      __new_finish = uninitialized_copy(iterator(_M_start), __position,
                                        __new_start);//将原vector的内容拷贝到新vector
      construct(__new_finish.base(), __x);//为新元素设置初始值
      ++__new_finish;//调整水位
      //拷贝安插点后的原内容（因为它可能被insert(p,x）之类的函数调用
      __new_finish = uninitialized_copy(__position, iterator(_M_finish),
                                        __new_finish);
    }
    __STL_UNWIND((destroy(__new_start,__new_finish), 
                  _M_deallocate(__new_start.base(),__len)));
    destroy(begin(), end());//析构并释放原来的vector
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    //调整迭代器 指向新的vector
    _M_start = __new_start.base();
    _M_finish = __new_finish.base();
    _M_end_of_storage = __new_start.base() + __len;
  }
}

1.1.3 vector iterator