void resize(size_type __new_size, const _Tp& __x) {if (__new_size < size()) erase(begin() + __new_size, end());　　　　// 擦除begin()+__new_size -> end()之间的元素elseinsert(end(), __new_size - size(), __x);}void resize(size_type __new_size) { resize(__new_size, _Tp()); }  // 这和上面一样,只不过是提供默认的参数.

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

template <class _Tp>
inline _Tp*
__copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result) {memmove(__result, __first, sizeof(_Tp) * (__last - __first));return __result + (__last - __first);
}

inline void _Destroy(_Tp* __pointer) {__pointer->~_Tp();  // 这里不是使用delete,而是调用元素对象本身的析构函数.
}

  void insert (iterator __pos, size_type __n, const _Tp& __x){ _M_fill_insert(__pos, __n, __x); }

template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_insert(iterator __position, size_type __n, const _Tp& __x)
{if (__n != 0) {   // __new_size - size() > 0 if (size_type(_M_end_of_storage - _M_finish) >= __n) {_Tp __x_copy = __x;const size_type __elems_after = _M_finish - __position;iterator __old_finish = _M_finish;if (__elems_after > __n) {uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);_M_finish += __n;copy_backward(__position, __old_finish - __n, __old_finish);fill(__position, __position + __n, __x_copy);}else {uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);_M_finish += __n - __elems_after;uninitialized_copy(__position, __old_finish, _M_finish);_M_finish += __elems_after;fill(__position, __old_finish, __x_copy);}}

  if (size_type(_M_end_of_storage - _M_finish) >= __n) {_Tp __x_copy = __x;const size_type __elems_after = _M_finish - __position;iterator __old_finish = _M_finish;if (__elems_after > __n) {  // 这下面的语句不会执行,因为_M_finish = _position uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);_M_finish += __n;copy_backward(__position, __old_finish - __n, __old_finish);fill(__position, __position + __n, __x_copy);}else {  // 从这里开始执行.uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);_M_finish += __n - __elems_after;  　　　　　　　　　　　　　　　　　　// _M_finish 向后移动__n-1uninitialized_copy(__position, __old_finish, _M_finish);   _M_finish += __elems_after;fill(__position, __old_finish, __x_copy);}}

template <class _ForwardIter, class _Size, class _Tp>
_ForwardIter
__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,const _Tp& __x, __false_type)
{_ForwardIter __cur = __first;__STL_TRY {for ( ; __n > 0; --__n, ++__cur)_Construct(&*__cur, __x);return __cur;}__STL_UNWIND(_Destroy(__first, __cur));
}

template <class _InputIter, class _ForwardIter>
_ForwardIter
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,_ForwardIter __result,__false_type)
{_ForwardIter __cur = __result;__STL_TRY {for ( ; __first != __last; ++__first, ++__cur)   // _position == old_position , 所以不会执行._Construct(&*__cur, *__first);return __cur;}__STL_UNWIND(_Destroy(__result, __cur));
}

   const size_type __old_size = size();        const size_type __len = __old_size + max(__old_size, __n);  // 这里不是简单的扩张两倍.因为不知道new_size和old_size之间的关系.iterator __new_start = _M_allocate(__len);　　　　　　　　　　 // 重新申请内存iterator __new_finish = __new_start;　　　　　　　　　　　　　　// 初始化__STL_TRY {__new_finish = uninitialized_copy(_M_start, __position, __new_start);  // 将原数组中_M_start -> _M_finish之间的元素复制到新数组中__new_finish = uninitialized_fill_n(__new_finish, __n, __x);　　　　　　 // 初始化_new_finish -> _new_finish + __n 之间的元素__new_finish= uninitialized_copy(__position, _M_finish, __new_finish);

　　　　destroy(_M_start, _M_finish);_M_deallocate(_M_start, _M_end_of_storage - _M_start);_M_start = __new_start;_M_finish = __new_finish;_M_end_of_storage = __new_start + __len;