C++后台开发STL之vector类2017/5/15

来源：互联网发布：xftp连接linux失败编辑：程序博客网时间：2024/06/02 04:48

浏览了一遍vector源码，在SGI STL头文件Stl_vector.h文件中，头文件一共定义了三个类，第一个是_Vector_alloc_base类，第二个是_Vector_base类，第三个则是外部接口vector类。

_Vector_base类，主要定义了基本的三个内存指针，以及配置器：

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_start 指向内存区首地址    _M_finish = _M_start;       //_M_finish 指向内存区首地址    _M_end_of_storage = _M_start + __n;_M_end_of_storage//指向内存区末尾地址  }  ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }protected:  _Tp* _M_start;  _Tp* _M_finish;  _Tp* _M_end_of_storage;  /*_M_data_allocator一般为二级配置器*/  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); }};

STL代码vector类无删减版：

//__STL_DEFAULT_ALLOCATOR(_Tp)约定使用默认配置器。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;//_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;  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: //vector类通用函数接口  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 //size的最大值，由于unsigned int的限制    { 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); }#ifdef __STL_THROW_RANGE_ERRORS//指针越界异常机制  void _M_range_check(size_type __n) const {    if (__n >= this->size())      __stl_throw_range_error("vector");  }  reference at(size_type __n)    { _M_range_check(__n); return (*this)[__n]; }  const_reference at(size_type __n) const    { _M_range_check(__n); return (*this)[__n]; }#endif /* __STL_THROW_RANGE_ERRORS */

/*vector的各种构造函数*/  explicit vector(const allocator_type& __a = allocator_type())    : _Base(__a) {}  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); }  explicit vector(size_type __n)    : _Base(__n, allocator_type())    { _M_finish = uninitialized_fill_n(_M_start, __n, _Tp()); }//用另一个vector容器初始化时，不是完整的复制所有的内存块，只是复制有效的内存块，并且此时容器的容量与size是大小一样。  vector(const vector<_Tp, _Alloc>& __x)     : _Base(__x.size(), __x.get_allocator())    { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); }#ifdef __STL_MEMBER_TEMPLATES  // Check whether it's an integral type.  If so, it's not an iterator.  template <class _InputIterator>  vector(_InputIterator __first, _InputIterator __last,         const allocator_type& __a = allocator_type()) : _Base(__a) {    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;    _M_initialize_aux(__first, __last, _Integral());  }  template <class _Integer>  void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) {    _M_start = _M_allocate(__n);    _M_end_of_storage = _M_start + __n;     _M_finish = uninitialized_fill_n(_M_start, __n, __value);  }  template <class _InputIterator>  void _M_initialize_aux(_InputIterator __first, _InputIterator __last,                         __false_type) {    _M_range_initialize(__first, __last, __ITERATOR_CATEGORY(__first));  }#else  vector(const _Tp* __first, const _Tp* __last,         const allocator_type& __a = allocator_type())    : _Base(__last - __first, __a)     { _M_finish = uninitialized_copy(__first, __last, _M_start); }#endif /* __STL_MEMBER_TEMPLATES */  ~vector() { destroy(_M_start, _M_finish); }  vector<_Tp, _Alloc>& operator=(const vector<_Tp, _Alloc>& __x);  void reserve(size_type __n) {    if (capacity() < __n) {      const size_type __old_size = size();      iterator __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish);      destroy(_M_start, _M_finish);      _M_deallocate(_M_start, _M_end_of_storage - _M_start);      _M_start = __tmp;      _M_finish = __tmp + __old_size;      _M_end_of_storage = _M_start + __n;    }  }

  // assign(), a generalized assignment member function.  Two  // versions: one that takes a count, and one that takes a range.  // The range version is a member template, so we dispatch on whether  // or not the type is an integer.  void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }  void _M_fill_assign(size_type __n, const _Tp& __val);#ifdef __STL_MEMBER_TEMPLATES  template <class _InputIterator>  void assign(_InputIterator __first, _InputIterator __last) {    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;    _M_assign_dispatch(__first, __last, _Integral());  }  template <class _Integer>  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)    { _M_fill_assign((size_type) __n, (_Tp) __val); }  template <class _InputIter>  void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)    { _M_assign_aux(__first, __last, __ITERATOR_CATEGORY(__first)); }  template <class _InputIterator>  void _M_assign_aux(_InputIterator __first, _InputIterator __last,                     input_iterator_tag);  template <class _ForwardIterator>  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,                     forward_iterator_tag); #endif /* __STL_MEMBER_TEMPLATES */  reference front() { return *begin(); }  const_reference front() const { return *begin(); }  reference back() { return *(end() - 1); }  const_reference back() const { return *(end() - 1); }  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);  }  void push_back() {    if (_M_finish != _M_end_of_storage) {      construct(_M_finish);      ++_M_finish;    }    else      _M_insert_aux(end());  }  void swap(vector<_Tp, _Alloc>& __x) {    __STD::swap(_M_start, __x._M_start);    __STD::swap(_M_finish, __x._M_finish);    __STD::swap(_M_end_of_storage, __x._M_end_of_storage);  }  iterator insert(iterator __position, const _Tp& __x) {    size_type __n = __position - begin();    if (_M_finish != _M_end_of_storage && __position == end()) {      construct(_M_finish, __x);      ++_M_finish;    }    else      _M_insert_aux(__position, __x);    return begin() + __n;  }  iterator insert(iterator __position) {    size_type __n = __position - begin();    if (_M_finish != _M_end_of_storage && __position == end()) {      construct(_M_finish);      ++_M_finish;    }    else      _M_insert_aux(__position);    return begin() + __n;  }#ifdef __STL_MEMBER_TEMPLATES  // Check whether it's an integral type.  If so, it's not an iterator.  template <class _InputIterator>  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;    _M_insert_dispatch(__pos, __first, __last, _Integral());  }  template <class _Integer>  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,                          __true_type)    { _M_fill_insert(__pos, (size_type) __n, (_Tp) __val); }  template <class _InputIterator>  void _M_insert_dispatch(iterator __pos,                          _InputIterator __first, _InputIterator __last,                          __false_type) {    _M_range_insert(__pos, __first, __last, __ITERATOR_CATEGORY(__first));  }#else /* __STL_MEMBER_TEMPLATES */  void insert(iterator __position,              const_iterator __first, const_iterator __last);#endif /* __STL_MEMBER_TEMPLATES */  void insert (iterator __pos, size_type __n, const _Tp& __x)    { _M_fill_insert(__pos, __n, __x); }  void _M_fill_insert (iterator __pos, size_type __n, const _Tp& __x);  void pop_back() {    --_M_finish;    destroy(_M_finish);  }  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;  }  void resize(size_type __new_size, const _Tp& __x) {    if (__new_size < size())       erase(begin() + __new_size, end());    else      insert(end(), __new_size - size(), __x);  }  void resize(size_type __new_size) { resize(__new_size, _Tp()); }  void clear() { erase(begin(), end()); }protected:#ifdef __STL_MEMBER_TEMPLATES  template <class _ForwardIterator>  iterator _M_allocate_and_copy(size_type __n, _ForwardIterator __first,                                                _ForwardIterator __last){    iterator __result = _M_allocate(__n);    __STL_TRY {      uninitialized_copy(__first, __last, __result);      return __result;    }    __STL_UNWIND(_M_deallocate(__result, __n));  }#else /* __STL_MEMBER_TEMPLATES */  iterator _M_allocate_and_copy(size_type __n, const_iterator __first,                                                const_iterator __last)  {    iterator __result = _M_allocate(__n);    __STL_TRY {      uninitialized_copy(__first, __last, __result);      return __result;    }    __STL_UNWIND(_M_deallocate(__result, __n));  }#endif /* __STL_MEMBER_TEMPLATES */#ifdef __STL_MEMBER_TEMPLATES  template <class _InputIterator>  void _M_range_initialize(_InputIterator __first,                             _InputIterator __last, input_iterator_tag)  {    for ( ; __first != __last; ++__first)      push_back(*__first);  }  // This function is only called by the constructor.   template <class _ForwardIterator>  void _M_range_initialize(_ForwardIterator __first,                           _ForwardIterator __last, forward_iterator_tag)  {    size_type __n = 0;    distance(__first, __last, __n);    _M_start = _M_allocate(__n);    _M_end_of_storage = _M_start + __n;    _M_finish = uninitialized_copy(__first, __last, _M_start);  }  template <class _InputIterator>  void _M_range_insert(iterator __pos,                       _InputIterator __first, _InputIterator __last,                       input_iterator_tag);  template <class _ForwardIterator>  void _M_range_insert(iterator __pos,                       _ForwardIterator __first, _ForwardIterator __last,                       forward_iterator_tag);#endif /* __STL_MEMBER_TEMPLATES */};

0 0