STL源码剖析之序列式容器vector

最新推荐文章于 2021-08-02 18:39:14 发布

ZH_learningblog

最新推荐文章于 2021-08-02 18:39:14 发布

阅读量474

点赞数

分类专栏： STL源码剖析文章标签： STL源码序列式容器 vector

本文链接：https://blog.csdn.net/HappyToEat/article/details/59129533

版权

本文深入探讨了STL中的序列式容器vector。vector基于动态数组实现，当元素数量增加时，它会自动扩展内存。文章介绍了_Vector_base类在内存管理中的作用，以及vector如何通过继承基类来实现元素的构造和析构操作，从而保持组件功能的独立。

摘要由CSDN通过智能技术生成

一、定义

vector底层是动态分配的数组，随着元素的增加，内部机制会自动扩充空间以容纳新的元素。

二、_Vector_base

vector继承自_Vector_base，实现对vector的内存管理功能。内部实现是通过继承空间分配基类_M_data_allocate成员变量，_M_allocate进行申请空间内存，_M_deallocate进行释放空间内存。而vector只需继承此基类，实现了组件功能的独立性。

// 空间分配的基类
template <class _Tp, class _Allocator, bool _IsStatic>
class _Vector_alloc_base {
public:
  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
          allocator_type;//定义空间分配的返回类型
  allocator_type get_allocator() const { return _M_data_allocator; }

  _Vector_alloc_base(const allocator_type& __a)//构造函数
    : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0) //初始化内存管理器，空间为0
  {}
  
protected:
  allocator_type _M_data_allocator;//定义内存管理器
  _Tp* _M_start;                 //空间起始位置
  _Tp* _M_finish;                //空间结束位置
  _Tp* _M_end_of_storage;        //可用空间结束位置

  _Tp* _M_allocate(size_t __n)   //分配空间内存
    { return _M_data_allocator.allocate(__n); }
  void _M_deallocate(_Tp* __p, size_t __n)//释放空间内存
    { if (__p) _M_data_allocator.deallocate(__p, __n); }
};

template <class _Tp, class _Alloc> 
class _Vector_base {
public:
  typedef _Alloc allocator_type;             //内嵌型获取类型
  allocator_type get_allocator() const { return allocator_type(); }

  _Vector_base(const _Alloc&)                   //构造函数
    : _M_start(0), _M_finish(0), _M_end_of_storage(0) {}
  _Vector_base(size_t __n, const _Alloc&)      //重载构造函数
    : _M_start(0), _M_finish(0), _M_end_of_storage(0) 
  {
    _M_start = _M_allocate(__n);
    _M_finish = _M_start;
    _M_end_of_storage = _M_start + __n;
  }

  ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }//析构函数

protected:
  _Tp* _M_start;//空间开始位置
  _Tp* _M_finish;//空间结束位置
  _Tp* _M_end_of_storage;//空间剩余可以结束位置

  typedef simple_alloc<_Tp, _Alloc> _M_data_allocator;
  _Tp* _M_allocate(size_t __n)//申请内存
    { return _M_data_allocator::allocate(__n); }
  void _M_deallocate(_Tp* __p, size_t __n) //释放内存
    { _M_data_allocator::deallocate(__p, __n); }
};

三、vector

vector继承了基类_Vector_base，就只需要管理元素的构造函数与析构函数。

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
  __STL_CLASS_REQUIRES(_Tp, _Assignable);
private:
  typedef _Vector_base<_Tp, _Alloc> _Base;//定义一个基类，用于空间管理
public:                                   //定义vector所使用到的类别
  typedef _Tp value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type* iterator;           //由此可见iterator为_Tp*
  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;

  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 _M_start; }            //获取第一个位置
  const_iterator begin() const { return _M_start; }
  iterator end() { return _M_finish; }            //获取最后元素标志位
  const_iterator end() const { retu