vector源码剖析

vector

前导准备

源码位置
* C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include

源码版本

• Copyright (c) 1992-2009 by P.J. Plauger. ALL RIGHTS RESERVED.
• Consult your license regarding permissions and restrictions.
  V5.20:0009

类定义

前导定义

template<class _Ty,
    class _Ax = allocator<_Ty> >
    class vector
        : public _Vector_val<_Ty, _Ax>
    {   // varying size array of values
public:
    typedef vector<_Ty, _Ax> _Myt;
    typedef _Vector_val<_Ty, _Ax> _Mybase;
    typedef typename _Mybase::_Alty _Alloc;

    typedef _Alloc allocator_type;
    typedef typename _Alloc::size_type size_type;
    typedef typename _Alloc::difference_type difference_type;
    typedef typename _Alloc::pointer pointer;
    typedef typename _Alloc::const_pointer const_pointer;
    typedef typename _Alloc::reference reference;
    typedef typename _Alloc::const_reference const_reference;
    typedef typename _Alloc::value_type value_type;

    typedef _Vector_iterator<_Mybase> iterator;
    typedef _Vector_const_iterator<_Mybase> const_iterator;

    typedef _STD reverse_iterator<iterator> reverse_iterator;
    typedef _STD reverse_iterator<const_iterator> const_reverse_iterator;

    .......

上面是vector 类开始处的代码片段。重点分析如下：
* allocator是专门的内存分配器，所有的内存分配的相关内容经由alloctor来处理。
* 针对基类的分析，_Vector_val，这里面存储着vector的操作数据
* 形如typedef typename 的定义
* 迭代器iterator的定义

allocator

我们可以在vc\crt\src看到如下这个宏定义，微软的编译器中默认这个_ALLOCATOR类是它的默认内存分配器，allocator是标准上的一个要求，当然我们可以实现不一样的内存分配器。

定义

 #define _ALLOCATOR allocator

接着我们看看这个类的定义

        // TEMPLATE CLASS _ALLOCATOR
template<class _Ty>
    class _ALLOCATOR
        : public _Allocator_base<_Ty>
    {   // generic allocator for objects of class _Ty
public:
    typedef _Allocator_base<_Ty> _Mybase;
    typedef typename _Mybase::value_type value_type;

    typedef value_type _FARQ *pointer;
    typedef value_type _FARQ& reference;
    typedef const value_type _FARQ *const_pointer;
    typedef const value_type _FARQ& const_reference;

    typedef _SIZT size_type;
    typedef _PDFT difference_type;

    };

依旧是使用typedef来定义出必要的类型，以备后续使用。
内部重要的函数是四个，构造析构函数，申请释放函数,我们先看申请和释放函数

申请

pointer allocate(size_type _Count)
    {   // allocate array of _Count elements
        return (_Allocate(_Count, (pointer)0));
    }

template<class _Ty> inline
    _Ty _FARQ *_Allocate(_SIZT _Count, _Ty _FARQ *)
    {   // allocate storage for _Count elements of type _Ty
    void *_Ptr = 0;

    if (_Count <= 0)
        _Count = 0;
    else if (((_SIZT)(-1) / sizeof (_Ty) < _Count)
        || (_Ptr = ::operator new(_Count * sizeof (_Ty))) == 0)
        _THROW_NCEE(bad_alloc, 0);

    return ((_Ty _FARQ *)_Ptr);
    }

我们来详细分析这个new的操作过程。

        || (_Ptr = ::operator new(_Count * sizeof (_Ty))) == 0)
69BF0DC4  cmp         dword ptr [_Count],1FFFFFFFh  
69BF0DCB  ja          std::_Allocate<std::pair<CString,CString> >+55h (69BF0DE5h)  
69BF0DCD  mov         eax,dword ptr [_Count]  
69BF0DD0  shl         eax,3  
69BF0DD3  push        eax  
69BF0DD4  call        operator new (69BDCC07h)  
69BF0DD9  add         esp,4  
69BF0DDC  mov         dword ptr [_Ptr],eax  
69BF0DDF  cmp         dword ptr [_Ptr],0  
69BF0DE3  jne         std::_Allocate<std::pair<CString,CString> >+73h (69BF0E03h)  

在69BF0DD4进入的跳转

operator new:
69BDCC07  jmp         operator new (69D5FD52h) 

69D5FD52  jmp         dword ptr [__imp_operator new (69DDA6F0h)]

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
        {       // try to allocate size bytes
6EA57DA0  mov         edi,edi  
6EA57DA2  push        ebp  
6EA57DA3  mov         ebp,esp  
6EA57DA5  sub         esp,10h  
        void *p;
        while ((p = malloc(size)) == 0)
6EA57DA8  mov         eax,dword ptr [size]  
6EA57DAB  push        eax  
6EA57DAC  call        malloc (6EA69C40h)  
6EA57DB1  add         esp,4  
6EA57DB4  mov         dword ptr [p],eax  
6EA57DB7  cmp         dword ptr [p],0  
6EA57DBB  jne         operator new+79h (6EA57E19h)  

这是一个内存申请的new。

释放

    void deallocate(pointer _Ptr, size_type)
        {   // deallocate object at _Ptr, ignore size
        ::operator delete(_Ptr);
        }

申请和释放函数，进行一定的参数判断后，直接使用operator delete和new来进行内存的申请。

构造

然后我们来研究一下构造和析构函数。如下所示

void construct(pointer _Ptr, const _Ty& _Val)
    {   // construct object at _Ptr with value _Val
        _Construct(_Ptr, _Val);
    }
        // TEMPLATE FUNCTION _Construct
template<class _Ty1,
    class _Ty2> inline
    void _Construct(_Ty1 _FARQ *_Ptr, _Ty2&& _Val)
    {   // construct object at _Ptr with value _Val
    void _FARQ *_Vptr = _Ptr;
    ::new (_Vptr) _Ty1(_STD forward<_Ty2>(_Val));
    }

template<class _Ty1> inline
    void _Construct(_Ty1 _FARQ *_Ptr)
    {   // construct object at _Ptr with default value
    void _FARQ *_Vptr = _Ptr;

    ::new (_Vptr) _Ty1();
    }

构造函数主要是通过replacement new来进行操作，在指定地址处构造数据
我们来详细分析一下这个::new (_Vptr) _Ty1(_STD forward<_Ty2>(_Val))的过程

我们来分析一下::new的汇编指令，来一探究竟。

    ::new (_Vptr) _Ty1(_STD forward<_Ty2>(_Val));
69BF16D3  mov         eax,dword ptr [_Vptr]  
69BF16D6  push        eax  
69BF16D7  push        8  
69BF16D9  call        operator new (69BE2AFDh)  
69BF16DE  add         esp,8  
69BF16E1  mov         dword ptr [ebp-0E0h],eax  
69BF16E7  mov         dword ptr [ebp-4],0  
69BF16EE  cmp         dword ptr [ebp-0E0h],0  
69BF16F5  je          std::_Construct<std::pair<CString,CString>,std::pair<CString,CString> const &>+87h (69BF1717h)  
69BF16F7  mov         ecx,dword ptr [_Val]  
69BF16FA  push        ecx  
69BF16FB  call        std::forward<std::pair<CString,CString> const &> (69BE1ECDh)  
69BF1700  add         esp,4  
69BF1703  push        eax  
69BF1704  mov         ecx,dword ptr [ebp-0E0h]  
69BF170A  call        std::pair<CString,CString>::pair<CString,CString> (69BDFB8Ch)  
69BF170F  mov         dword ptr [ebp-0F4h],eax  
69BF1715  jmp         std::_Construct<std::pair<CString,CString>,std::pair<CString,CString> const &>+91h (69BF1721h)  
69BF1717  mov         dword ptr [ebp-0F4h],0  
69BF1721  mov         edx,dword ptr [ebp-0F4h]  
69BF1727  mov         dword ptr [ebp-0ECh],edx  
69BF172D  mov         dword ptr [ebp-4],0FFFFFFFFh  

我们在69BF16D9处进入call，看看它执行到了哪里

operator new:
69BE2AFD  jmp         operator new (69BF2810h) 

inline void *__CRTDECL operator new(size_t, void *_Where) _THROW0()
    {   // construct array with placement at _Where
69BF2810  push        ebp  
69BF2811  mov         ebp,esp  
69BF2813  sub         esp,0C0h  
69BF2819  push        ebx  
69BF281A  push        esi  
69BF281B  push        edi  
69BF281C  lea         edi,[ebp-0C0h]  
69BF2822  mov         ecx,30h  
69BF2827  mov         eax,0CCCCCCCCh  
69BF282C  rep stos    dword ptr es:[edi]  
    return (_Where);
69BF282E  mov         eax,dword ptr [_Where]  
    }
69BF2831  pop         edi  
69BF2832  pop         esi  
69BF2833  pop         ebx  
69BF2834  mov         esp,ebp  
69BF2836  pop         ebp  
69BF2837  ret  

如上，这个是一个std的new操作符的一个operator的操作，函数中只是参数代表的地址。
然后返回上一个函数中，此时调用一下forward，接着调用某种类型的构造函数，我们的是pair的构造函数。

析构

void destroy(pointer _Ptr)
    {   // destroy object at _Ptr
        _Destroy(_Ptr);
    }

    // TEMPLATE FUNCTION _Destroy
template<class _Ty> inline
    void _Destroy(_Ty _FARQ *_Ptr)
    {   // destroy object at _Ptr
    _Ptr->~_Ty();
    }
template<> inline
    void _Destroy(char _FARQ *)
    {   // destroy a char (do nothing)
    }

template<> inline
    void _Destroy(wchar_t _FARQ *)
    {   // destroy a wchar_t (do nothing)
    }

析构函数则是调用对象的析构函数，另外针对不同的数据类型进行不同的析构处理。此处使用了函数模板偏特化

_Vector_val基类

        // TEMPLATE CLASS _Vector_val
template<class _Ty,
    class _Alloc>
    class _Vector_val
        : public _Container_base
    {   // base class for vector to hold data
public:
    typedef typename _Alloc::template rebind<_Ty>::other _Alty;

 #if _ITERATOR_DEBUG_LEVEL == 0
    _Vector_val(_Alloc _Al = _Alloc())
        : _Alval(_Al)
        {   // construct allocator from _Al
        _Myfirst = 0;
        _Mylast = 0;
        _Myend = 0;
        }

    ~_Vector_val()
        {   // destroy proxy
        }

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
    _Vector_val(_Alloc _Al = _Alloc())
        : _Alval(_Al)
        {   // construct allocator from _Al
        typename _Alloc::template rebind<_Container_proxy>::other
            _Alproxy(_Alval);
        this->_Myproxy = _Alproxy.allocate(1);
        _Cons_val(_Alproxy, this->_Myproxy, _Container_proxy());
        this->_Myproxy->_Mycont = this;

        _Myfirst = 0;
        _Mylast = 0;
        _Myend = 0;
        }

    ~_Vector_val()
        {   // destroy proxy
        typename _Alloc::template rebind<_Container_proxy>::other
            _Alproxy(_Alval);
        this->_Orphan_all();
        _Dest_val(_Alproxy, this->_Myproxy);
        _Alproxy.deallocate(this->_Myproxy, 1);
        this->_Myproxy = 0;
        }
 #endif /* _ITERATOR_DEBUG_LEVEL == 0 */

    typedef typename _Alty::size_type size_type;
    typedef typename _Alty::difference_type difference_type;
    typedef typename _Alty::pointer pointer;
    typedef typename _Alty::const_pointer const_pointer;
    typedef typename _Alty::reference reference;
    typedef typename _Alty::const_reference const_reference;
    typedef typename _Alty::value_type value_type;

    pointer _Myfirst;   // pointer to beginning of array
    pointer _Mylast;    // pointer to current end of sequence
    pointer _Myend; // pointer to end of array
    _Alty _Alval;   // allocator object for values
    };

这个基类中主要存储的是vector的数据操作指针，重要的是下面这个三个结构

pointer _Myfirst;   // pointer to beginning of array
pointer _Mylast;    // pointer to current end of sequence
pointer _Myend; // pointer to end of array

其他函数对其进行初始化和销毁的处理，根据debug级别进行不同的处理，也使用了typedef来定义出具体的类型。

iterator

vector的迭代器分两种四类

typedef _Vector_iterator<_Mybase> iterator;
typedef _Vector_const_iterator<_Mybase> const_iterator;
typedef _STD reverse_iterator<iterator> reverse_iterator;
typedef _STD reverse_iterator<const_iterator> const_reverse_iterator;

分是否const和正向或反向迭代器

vector 迭代器

_Vector_iterator定义

template<class _Myvec>
    class _Vector_iterator
        : public _Vector_const_iterator<_Myvec>
    {   // iterator for mutable vector
public:
    typedef _Vector_iterator<_Myvec> _Myiter;
    typedef _Vector_const_iterator<_Myvec> _Mybase;
    typedef random_access_iterator_tag iterator_category;

    typedef typename _Myvec::value_type value_type;
    typedef typename _Myvec::difference_type difference_type;
    typedef typename _Myvec::pointer pointer;
    typedef typename _Myvec::reference reference;

    _Vector_iterator()
        {   // construct with null vector pointer
        }

    _Vector_iterator(pointer _Parg, const _Container_base *_Pvector)
        : _Mybase(_Parg, _Pvector)
        {   // construct with pointer _Parg
        }

定义中，有声明出此迭代器的类型random_access_iterator_tag，决定了当前迭代器能做的操作。数据类型value_type等等。以及定义出构造函数。
我们可以看看vector中的迭代器的构造，就可以知道vector向迭代器传递了哪些数据。

typedef _Vector_iterator<_Mybase> iterator;

iterator begin()
{   
    // return iterator for beginning of mutable sequence
    return (iterator(this->_Myfirst, this));
}

vector向迭代器传递了数据操作首地址和类操作this指针，将数据操作权递交给迭代器。_Vector_iterator将数据指针传递给基类存储。

_Vector_iterator对数据的操作

    ....
    _Myiter operator-(difference_type _Off) const
        {   // return this - integer
        _Myiter _Tmp = *this;
        return (_Tmp -= _Off);
        }

    difference_type operator-(const _Mybase& _Right) const
        {   // return difference of iterators
        return (*(_Mybase *)this - _Right);
        }

    reference operator[](difference_type _Off) const
        {   // subscript
        return (*(*this + _Off));
        }
    ....

那么它是如何对数据的操作的呢，如上所示，返回的类型就是类开始处已经定义好的类型之一。通过迭代器来操作具体容器的数据。如何操作以及类型都由迭代器做具体的处理。类型由typedef迭代器的时候指定要操作数据的类型，而如何操作则由具体的迭代器定义来定义出何种的访问方式。

vector迭代器基类

_Vector_iterator 继承自 _Vector_const_iterator 继承自 _Iterator012

        // TEMPLATE CLASS iterator
template<class _Category,
    class _Ty,
    class _Diff = ptrdiff_t,
    class _Pointer = _Ty *,
    class _Reference = _Ty&>
    struct iterator
    {   // base type for all iterator classes
    typedef _Category iterator_category;
    typedef _Ty value_type;
    typedef _Diff difference_type;
    typedef _Diff distance_type;    // retained
    typedef _Pointer pointer;
    typedef _Reference reference;
    };

template<class _Category,
    class _Ty,
    class _Diff,
    class _Pointer,
    class _Reference,
    class _Base>
    struct _Iterator012
        : public _Base
    {
    typedef _Category iterator_category;
    typedef _Ty value_type;
    typedef _Diff difference_type;
    typedef _Diff distance_type;    // retained
    typedef _Pointer pointer;
    typedef _Reference reference;
    };

这里是迭代器的最基本的定义。

template<class _Myvec>
    class _Vector_const_iterator
        : public _Iterator012<random_access_iterator_tag,
            typename _Myvec::value_type,
            typename _Myvec::difference_type,
            typename _Myvec::const_pointer,
            typename _Myvec::const_reference,
            _Iterator_base>
    {   // iterator for nonmutable vector
public:
.........

我们的vector迭代器如上继承，指定我们是一个随机存储迭代器，可以随机索取数据，定指定其他四项数据类型，供索引数据使用。

iterator_traits

我们继续看vector的定义，接着我们看到了构造函数，其中有这么一幕。

    ......
    template<class _Iter>
        vector(_Iter _First, _Iter _Last)
        : _Mybase()
        {   // construct from [_First, _Last)
        _Construct(_First, _Last, _Iter_cat(_First));
        }

    template<class _Iter>
        void _Construct(_Iter _Count, _Iter _Val, _Int_iterator_tag)
        {   // initialize with _Count * _Val
        size_type _Size = (size_type)_Count;
        _Ty _Newval = (_Ty)_Val;
        _Construct_n(_Size, _STD addressof(_Newval));
        }

    template<class _Iter>
        void _Construct(_Iter _First,
            _Iter _Last, input_iterator_tag)
        {   // initialize with [_First, _Last), input iterators
        _TRY_BEGIN
        insert(begin(), _First, _Last);
        _CATCH_ALL
        _Tidy();
        _RERAISE;
        _CATCH_END
        }
    ......

vector 支持各种构造函数，值得一说的是上面的这种构造方式，使用_Iter_cat函数取出_First对应的迭代器类型，根据不同的迭代器类型，执行不同的构造算法。下面我们来看看是如何通过迭代器获取到迭代器类型的，这是一个类型识别的过程。

        // TEMPLATE FUNCTION _Iter_cat
template<class _Iter> inline
    typename iterator_traits<_Iter>::iterator_category
        _Iter_cat(const _Iter&)
    {   // return category from iterator argument
    typename iterator_traits<_Iter>::iterator_category _Cat;
    return (_Cat);
    }

内部主要使用iterator_traits来做核心任务，这个是迭代器类型识别的萃取类。其如下定义

        // TEMPLATE CLASS iterator_traits
template<class _Iter>
    struct iterator_traits
    {   // get traits from iterator _Iter
    typedef typename _Iter::iterator_category iterator_category;
    typedef typename _Iter::value_type value_type;
    typedef typename _Iter::difference_type difference_type;
    typedef difference_type distance_type;  // retained
    typedef typename _Iter::pointer pointer;
    typedef typename _Iter::reference reference;
    };

template<class _Ty>
    struct iterator_traits<_Ty *>
    {   // get traits from pointer
    typedef random_access_iterator_tag iterator_category;
    typedef _Ty value_type;
    typedef ptrdiff_t difference_type;
    typedef ptrdiff_t distance_type;    // retained
    typedef _Ty *pointer;
    typedef _Ty& reference;
    };

template<> struct iterator_traits<_Bool>
    {   // get traits from integer type
    typedef _Int_iterator_tag iterator_category;
    };

template<> struct iterator_traits<char>
    {   // get traits from integer type
    typedef _Int_iterator_tag iterator_category;
    };
    .....

iterator_traits 提供了多种特化的版本，如上，支持原始指针和迭代器的类型。还支持bool， char，等等数据类型的类型识别。

vector容器自身对数据的操作

push_back

......
    void push_back(const _Ty& _Val)
        {   // insert element at end
        if (_Inside(_STD addressof(_Val)))
            {   // push back an element
            size_type _Idx = _STD addressof(_Val) - this->_Myfirst;
            if (this->_Mylast == this->_Myend)
                _Reserve(1);
            _Orphan_range(this->_Mylast, this->_Mylast);
            _Cons_val(this->_Alval,
                this->_Mylast,
                this->_Myfirst[_Idx]);
            ++this->_Mylast;
            }
        else
            {   // push back a non-element
            if (this->_Mylast == this->_Myend)
                _Reserve(1);
            _Orphan_range(this->_Mylast, this->_Mylast);
            _Cons_val(this->_Alval,
                this->_Mylast,
                _Val);
            ++this->_Mylast;
            }
        }

push_back 的逻辑较为复杂：
* 首先，判断要插入的值的地址是否位于vector所已有数据的地址范围内。
* 如果是，那么计算出该值的位置偏移，使用这个值来初始化数据。
* 如果这是一个新值，那么我要判断是否我还有可用空间。
* 如果没有，那么使用_Reserve来申请空间
* 如果有可用空间，那么使用_Cons_val来初始化数据
* 最后递增vector队尾偏移。
接着我们分别介绍其中几个核心的函数

_Reserve

那么，vector是如何预留空间的呢

.....
    void _Reserve(size_type _Count)
        {   // ensure room for _Count new elements, grow exponentially
        size_type _Size = size();
        if (max_size() - _Count < _Size)
            _Xlen();
        else if ((_Size += _Count) <= capacity())
            ;
        else
            reserve(_Grow_to(_Size));
        }

        _SIZT max_size() const _THROW0()
        {   // estimate maximum array size
        _SIZT _Count = (_SIZT)(-1) / sizeof (_Ty);
        return (0 < _Count ? _Count : 1);
        }

此函数做参数合法判断，确定不能超过最大大小，并且如果已经有容量符合要求了，那么什么都不做，如果容量确实不够，那么增长容量。
那么具体容量是怎么增长的，有个什么规则呢

.....
    size_type _Grow_to(size_type _Count) const
        {   // grow by 50% or at least to _Count
        size_type _Capacity = capacity();

        _Capacity = max_size() - _Capacity / 2 < _Capacity
            ? 0 : _Capacity + _Capacity / 2;    // try to grow by 50%
        if (_Capacity < _Count)
            _Capacity = _Count;
        return (_Capacity);
        }

从上面的我们可以看出，容量每次增长50%，这是vs2010 stl这个版本的实现，其他的实现可能不同。
我们知道了容量的增量了，那么具体它怎么实现内存的操作的呢。

......
    void reserve(size_type _Count)
        {   // determine new minimum length of allocated storage
        if (max_size() < _Count)
            _Xlen();    // result too long
        else if (capacity() < _Count)
            {   // not enough room, reallocate
            pointer _Ptr = this->_Alval.allocate(_Count);

            _TRY_BEGIN
            _Umove(this->_Myfirst, this->_Mylast, _Ptr);
            _CATCH_ALL
            this->_Alval.deallocate(_Ptr, _Count);
            _RERAISE;
            _CATCH_END

            size_type _Size = size();
            if (this->_Myfirst != 0)
                {   // destroy and deallocate old array
                _Destroy(this->_Myfirst, this->_Mylast);
                this->_Alval.deallocate(this->_Myfirst,
                    this->_Myend - this->_Myfirst);
                }

            this->_Orphan_all();
            this->_Myend = _Ptr + _Count;
            this->_Mylast = _Ptr + _Size;
            this->_Myfirst = _Ptr;
            }
        }

这里申请一个增长后容量大小的空间，然后将原始空间析构释放，之后计算新的头尾偏移值。

_Cons_val

回到push_back函数中，当申请空间等操作都完成后，开始在这块空间上构造数据。

template<class _Alloc,
    class _Ty1,
    class _Ty2>
    void _Cons_val(_Alloc& _Alval, _Ty1 *_Pdest, _Ty2&& _Src)
    {   // construct using allocator
    _Alval.construct(_Pdest, _STD forward<_Ty2>(_Src));
    }

实际上是调用vector的内存分配器去做实际的操作。这个在开始allocator中我们就接触到了如何构造析构和申请释放内存的操作。