STL 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;

//特征萃取

  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 { 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); }

//此容器迭代器是用普通指针实做出来的

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

//at成员函数，带异常处理

  explicit vector(const allocator_type& __a = allocator_type())    : _Base(__a) {}

//通过分配器来构造vector，默认的构造函数

  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(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);  }

//用__value值初始__n个元素

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