STL::vector 探索

成员变量
_MyFirst
_MyLast
_MyEnd

底层函数
bool _Buy(size_type _Capacity) 开辟一段内部存储空间
void _Destroy(pointer _First, pointer _Last) 对这些元素做析构操作 (或什么也不干)
void _Tidy() 销毁内部存储空间 (包括对内部元素的析构操作)

_OutIt unchecked_copy(_InIt _First, _InIt _Last, _OutIt _Dest) 拷贝元素(_Dest中的元素已初始化，这里对_Dest中的每个元素调用 = 操作)
pointer _Ucopy(_Iter _First, _Iter _Last, pointer _Ptr) 拷贝元素(_Dest中的元素未初始化，这里对_Dest中的每个元素调用拷贝构造函数)
pointer _Umove(_Iter _First, _Iter _Last, pointer _Ptr) 移动元素(_Dest中的元素未初始化，直接调用 memcpy 拷贝内存)
pointer _Ufill(pointer _Ptr, size_type _Count, const _Ty &_Val) 给元素赋值 (_Dest中的元素未初始化，对_Dest中的每个元素调用拷贝构造函数)
void fill(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) 给元素赋值 (_Dest中的元素已初始化，对_Dest中的每个元素调用 = 操作)

中间函数
void _Construct_n(size_type _Count, const _Ty& _Val) 开辟 _Count 空间并用 _Val 初始化
void _Insert(iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag) 内部存储空间的扩展代码在这，每次扩大50%
void _Insert_n(iterator _Where, size_type _Count, const _Ty& _Val)
iterator erase(iterator _First, iterator _Last)

对外接口
size_type capacity() _Myend - _Myfirst
size_type size()  _Mylast - _Myfirst


几个关键函数简化
template
        void _Insert(iterator _Where,
            _Iter _First, _Iter _Last, forward_iterator_tag)
        {    // insert [_First, _Last) at _Where, forward iterators
        size_type _Count = _Last - _First;
        size_type _Capacity = capacity();

        if (_Count == 0)
            ;
        else if (_Capacity < size() + _Count)
        {    // not enough room, reallocate
            _Capacity = max_size() - _Capacity / 2 < _Capacity
                ? 0 : _Capacity + _Capacity / 2;    // try to grow by 50%
            if (_Capacity < size() + _Count)
                _Capacity = size() + _Count;
            _Ty * _Newvec = (_Ty *)::operator new(_Count * sizeof (_Ty));
            _Ty * _Ptr = _Newvec;

            _Ptr = _Umove(_Myfirst, _Where, _Newvec);    // copy prefix
            _Ptr = _Ucopy(_First, _Last, _Ptr);    // add new stuff
            _Umove(_Where, _Mylast, _Ptr);    // copy suffix

            _Count += size();
            if (_Myfirst != 0)
            {
                ::operator delete (_Myfirst);
            }

            _Myend = _Newvec + _Capacity;
            _Mylast = _Newvec + _Count;
            _Myfirst = _Newvec;
        }
        else if ((size_type)(end() - _Where) < _Count)
        {    // new stuff spills off end
            _Umove(_Where, _Mylast, _Where + _Count);    // copy suffix
            _Iter _Mid = _First;
            advance(_Mid, end() - _Where);
            _Ucopy(_Mid, _Last, _Mylast);    // insert new stuff off end

            _Mylast += _Count;

            unchecked_copy(_First, _Mid, _Where);    // insert to old end
            }
        else
            {    // new stuff can all be assigned
            pointer _Oldend = _Mylast;
            _Mylast = _Umove(_Oldend - _Count, _Oldend, _Mylast);    // copy suffix
            _Unchecked_move_backward(_Where, _Oldend - _Count, _Oldend);    // copy hole

            unchecked_copy(_First, _Last, _Where);    // insert into hole
            }
        }

这个 Insert 函数分了几种情况处理
1. _Capacity < size() + _Count ,这时需要扩大存储空间了,每次扩大50%，然后移动内容
1) 移动 [_MyFirst, _Where) 到新数组
2) 拷贝 [_First, _Last)
3) 移动 [_Where, _MyLast)

原存储空间:


新存储空间:
 

2. size() + _Count < _Capacity && end() < _Where + _Count, 也就是插入的内容超出了 _MyLast.
1) 移动 [_Where, _MyLast) 到 [size() + _Count, ...)
2) 拷贝 [_Mid, _Last) 到 [size(), ...)   //目的空间未初始化
3) 拷贝 [_First, _Mid) 到 [_Where, ...)//目的空间已初始化

原存储空间:

新存储空间:

3.剩余情况
1）移动 [_Where, _MyLast) 到 [_Where + _Count, ...) //分了两步
2) 拷贝 [_First, _Last)

原存储空间:
新存储空间: