_vector.h

A port of the original STL to many platforms.可以配合多种编译器使用,特别是在使用intel编译器时可以很好的优化代码性能.

         const allocator_type& __a = allocator_type())
    : _ConstructCheck(__first, __last),
      _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
    _M_iter_list(&_M_non_dbg_impl) {}
#endif /* _STLP_MEMBER_TEMPLATES */

  _Self& operator=(const _Self& __x) {
    if (this != &__x) {
      _Invalidate_all();
      _M_non_dbg_impl = __x._M_non_dbg_impl;
    }
    return *this;
  }

  void reserve(size_type __n) {
    if (capacity() < __n)
      _Invalidate_all();
    _M_non_dbg_impl.reserve(__n);
  }

  reference front() {
    _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
    return *begin();
  }
  const_reference front() const {
    _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
    return *begin();
  }
  reference back() {
    _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
    return *(--end());
  }
  const_reference back() const {
    _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
    return *(--end());
  }

  void swap(_Self& __x) {
    _M_iter_list._Swap_owners(__x._M_iter_list);
    _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
  }

#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
  iterator insert(iterator __pos, const _Tp& __x = _Tp()) {
#else
  iterator insert(iterator __pos, const _Tp& __x) {
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
    _Check_Overflow(1);
    return iterator(&_M_iter_list, _M_non_dbg_impl.insert(__pos._M_iterator, __x));
  }

#if defined(_STLP_DONT_SUP_DFLT_PARAM)
  iterator insert(iterator __pos)
  { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/

#if defined (_STLP_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 _AreSameUnCVTypes<_InputIterator, iterator>::_Ret _IsNonConstIterator;
    typedef typename _AreSameUnCVTypes<_InputIterator, const_iterator>::_Ret _IsConstIterator;
    typedef typename _Lor2<_IsNonConstIterator, _IsConstIterator>::_Ret _DoCheck;
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
    //Sequence requirements 23.1.1 Table 67:
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_not_owner(&_M_iter_list, __first, _DoCheck()));
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__pos._M_iterator,
                           _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
    _Compare_Capacity(__old_capacity);
  }
#else
  void insert (iterator __pos,
               const value_type *__first, const value_type *__last) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first,__last))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
    _Compare_Capacity(__old_capacity);
  }

  void insert(iterator __pos,
              const_iterator __first, const_iterator __last) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
    //Sequence requirements 23.1.1 Table 67:
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_not_owner(&_M_iter_list, __first, __true_type()));
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
    _Compare_Capacity(__old_capacity);
}
#endif

  void insert (iterator __pos, size_type __n, const _Tp& __x){
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
    _Check_Overflow(__n);
    _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
  }

  void pop_back() {
    _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
    _Invalidate_iterator(end());
    _M_non_dbg_impl.pop_back();
  }
  iterator erase(iterator __pos) {
    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
    _Invalidate_iterators(__pos, end());
    return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
  }
  iterator erase(iterator __first, iterator __last) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
    _Invalidate_iterators(__first, end());
    return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
  }

#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
  void resize(size_type __new_size, const _Tp& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
#else
  void resize(size_type __new_size, const _Tp& __x) {
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
    if (__new_size > capacity()) {
      _Invalidate_all();
    }
    else if (__new_size < size()) {
      _Invalidate_iterators(begin() + __new_size, end());
    }
    _M_non_dbg_impl.resize(__new_size, __x);
  }

#if defined (_STLP_DONT_SUP_DFLT_PARAM)
  void resize(size_type __new_size) { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/

#if defined (_STLP_MEMBER_TEMPLATES)
private:
  template <class _Integer>
  void _M_assign_dispatch(_Integer __n, _Integer __val,
                          const __true_type& /*_IsIntegral*/) {
    _M_check_assign(__n);
    _M_non_dbg_impl.assign(__n, __val);
  }

  template <class _InputIter>
  void _M_assign_dispatch(_InputIter __first, _InputIter __last,
                          const __false_type& /*_IsIntegral*/) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
    size_type __old_size = size();
    size_type __old_capacity = capacity();
    iterator __old_end = end();
    _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
    if (__old_capacity != 0) {
      if (empty() || (capacity() > __old_capacity)) {
        _Invalidate_all();
      }
      else if (size() < __old_size) {
        _Invalidate_iterators(begin() + size(), __old_end);
      }
    }
  }

public:
  template <class _InputIterator>
  void assign(_InputIterator __first, _InputIterator __last) {
    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
    _M_assign_dispatch(__first, __last, _Integral());
  }
#else
private:
  void _M_assign(const value_type *__first, const value_type *__last) {
    size_type __len = distance(__first, __last);
    _M_check_assign(__len);
    _M_non_dbg_impl.assign(__first, __last);
  }
public:
  void assign(const value_type *__first, const value_type *__last) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first,__last))
    _M_assign(__first, __last);
  }

  void assign(const_iterator __first, const_iterator __last) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
    _M_assign(__first._M_iterator, __last._M_iterator);
  }
#endif

private:
  void _M_check_assign(size_type __n) {
    if (__n > capacity()) {
      _Invalidate_all();
    }
    else if (__n < size()) {
      _Invalidate_iterators(begin() + __n, end());
    }
  }

public:
  void assign(size_type __n, const _Tp& __val) {
    _M_check_assign(__n);
    _M_non_dbg_impl.assign(__n, __val);
  }

  void clear() {
    _Invalidate_all();
    _M_non_dbg_impl.clear();
  }
  void push_back(const _Tp& __x) {
    _Check_Overflow(1);
    _M_non_dbg_impl.push_back(__x);
  }
};

_STLP_END_NAMESPACE

#undef _STLP_NON_DBG_VECTOR

#endif /* _STLP_DBG_VECTOR_H */

// Local Variables:
// mode:C++
// End: