STL源码剖析 --vector

vector容器概述
      vector的数据安排以及操作方式，与array非常相似。两者的唯一区别在于空间的运用的灵活性。array是静态空间，一旦配置了就不能改变；要换个大（或小）一点的房子，可以，一切琐细都得由客户端自己来：首先配置一块新空间，然后将元素从旧址一一搬往新址，再把原来的空间释还给系统。vector是动态空间，随着元素的加入，它的内部机制会自行扩充空间以容纳新元素。因此，vector的运用对于内存的合理利用与运用的灵活性有很大的帮助，我们再也不必因为害怕空间不足而一开始要求一个大块头的array了，我们可以安心使用array，吃多少用多少。
      vector的实现技术，关键在于其对大小的控制以及重新配置时的数据移动效率。一旦vector的旧有空间满载，如果客户端每新增一个元素，vector的内部只是扩充一个元素的空间，实为不智。因为所谓扩充空间（不论多大），一如稍早所说，是”配置新空间/数据移动/释还旧空间“的大工程，时间成本很高，应该加入某种未雨绸缪的考虑。稍后我们便可看到SGI
vector的空间配置策略了。
      另外，由于vector维护的是一个连续线性空间，所以vector支持随机存取。
      注意：vector动态增加大小时，并不是在原空间之后持续新空间（因为无法保证原空间之后尚有可供配置的空间），而是以原大小的两倍另外配置一块较大的空间，然后将原内容拷贝过来，然后才开始在原内容之后构造新元素，并释放原空间。因此，对vector的任何操作，一旦引起空间重新配置，指向原vector的所有迭代器就都失效了。这是程序员易犯的一个错误，务需小心。

Vector的数据结构

我们从最简单的开始，Vector的数据结构相当简单，由于需要判断内存是否够用，所以要用到三个指针，分别指向头，目前使用空间的尾，目前可用空间的尾。其源代码如下：

//对源码略作调整
iterator _M_start;                  //表示目前使用空间的头
iterator _M_finish;                 //表示目前使用空间的尾（尾：最后一个元素的下一个位置）
iterator _M_end_of_storage;         //表示目前可用空间的尾

iterator begin() { return _M_start; }
iterator end()   { return _M_finish; }

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

Vector的迭代器

vector维护的是一段连续的内存空间，所以不论容器中元素的型别为何，普通指针都可以作为vector的迭代器而满足所有必要的条件。vector支持随机存取，所以vector提供的是Random Access Iterator。

下面来看看vector关于迭代器的源码：

template <class T, class Alloc = alloc>
class vector
{
public:
// vector内部是连续内存空间，所以迭代器采用原生指针即可
typedef value_type* iterator;
//以下为满足Traits功能定义的内嵌型别
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef const value_type* const_iterator;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef ptrdiff_t difference_type;
typedef size_t size_type;
}

vector的构造函数

默认构造函数

在使用vector的时候，我们通常会有如下定义：

#include <vector>

vector<int> vec;

在上述定义中，调用了vector的默认构造函数，其默认不分配内存空间，如下：

// vector的默认构造函数默认不分配内存空间

vector() : start(0), finish(0), end_of_storage(0) {}

带参构造函数

通常，vector的初始化可以指定元素个数和初始化类型。如下：

vector<int> vec(10,1); // 将vec初始化为10个1

vector提供下面的构造函数以支持上述初始化操作：

// 构造函数，允许指定vector的元素个数和初值
vector(size_type n, const T& value) { fill_initialize(n, value); }
vector(int n, const T& value) { fill_initialize(n, value); }
vector(long n, const T& value) { fill_initialize(n, value); }
// 需要对象提供默认构造函数
explicit vector(size_type n) { fill_initialize(n, T()); }
/**
* 填充并予以初始化
*/
void fill_initialize(size_type n, const T& value)
{
start = allocate_and_fill(n, value);
finish = start + n;                         // 设置当前使用内存空间的结束点
//这里不过多的分配内存
end_of_storage = finish;
}
/**
* 配置一块大小为n的内存空间，并予以填充
*/
iterator allocate_and_fill(size_type n, const T& x)
{
// 调用STL的空间配置器配置一块大小为n的内存空间
iterator result = data_allocator::allocate(n);
// 调用底层函数uninitialized_fill_n予以填充
uninitialized_fill_n(result, n, x);
return result;
}

这里面调用了uninitialized_fill_n函数，这个函数是STL的内存基本处理函数，存放在stl_uninitialized.h中，下面来看看它的源码：

// 如果copy construction和operator =等效, 并且destructor is trivial
// 那么就可以使用本函数
template <class ForwardIterator, class Size, class T>
inline ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
const T& x, __true_type)
{
return fill_n(first, n, x);
}
// 不是POD类型使用以下函数
template <class ForwardIterator, class Size, class T>
ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
const T& x, __false_type)
{
ForwardIterator cur = first;
for ( ; n > 0; --n, ++cur)
construct(&*cur, x);
return cur;
}
// 利用type_traits来判断是否是POD类型
template <class ForwardIterator, class Size, class T, class T1>
inline ForwardIterator __uninitialized_fill_n(ForwardIterator first, Size n,
const T& x, T1*)
{
typedef typename __type_traits<T1>::is_POD_type is_POD;
return __uninitialized_fill_n_aux(first, n, x, is_POD());
}
// 利用Iterator_traits来萃取出其值类型
template <class ForwardIterator, class Size, class T>
inline ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n,
const T& x)
{
return __uninitialized_fill_n(first, n, x, value_type(first));
}

这里先学习 insert() 函数（后面介绍另一个版本的
insert()：插入n个指定元素）

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);  //没有剩余空间或插入位置为尾前面，则则调用_M_insert_aux()
return begin() + __n;   //返回插入位置
}

_M_insert_aux()函数:

template <class _Tp, class _Alloc>
void
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
{
if (_M_finish != _M_end_of_storage) {          //还有备用空间，表明插入位置不是尾端
construct(_M_finish, *(_M_finish - 1));    //以空间最后一个对象为蓝本构造新对象元素(位于备用空间的起始位置)
++_M_finish;                               //调整迭代器尾端位置，指向最后一个元素的后一个位置
_Tp __x_copy = __x;                        //赋值对象

copy_backward(__position, _M_finish - 2, _M_finish - 1);
*__position = __x_copy;                    //迭代器位置赋指定值
}
else {     //无备用空间
const size_type __old_size = size();        //保存当前空间中的元素个数
const size_type __len = __old_size != 0 ? 2 * __old_size : 1; //长度为原空间元素个数(不为0时)的两倍
iterator __new_start = _M_allocate(__len);     //分配该长度的空间
iterator __new_finish = __new_start;           //新空间为空(初始化)

__STL_TRY{
__new_finish = uninitialized_copy(_M_start, __position, __new_start); //复制初始化，将插入位置前的元素复制到新空间
construct(__new_finish, __x);    //在指定的插入位置构造新对象，并为新元素设定初值__X
++__new_finish;                  //调整迭代器位置

//将插入位置后的元素复制到新空间插入元素位置的后面，完成最后的插入操作
__new_finish = uninitialized_copy(__position, _M_finish, __new_finish);

} //捕捉异常，如有一个复制出错，则析构并释放空间
__STL_UNWIND((destroy(__new_start, __new_finish), _M_deallocate(__new_start, __len)));

//析构并释放原 vector
destroy(begin(), end());
_M_deallocate(_M_start, _M_end_of_storage - _M_start);

//调整迭代器，指向新 vector
_M_start = __new_start;
_M_finish = __new_finish;
_M_end_of_storage = __new_start + __len;
}
}

 push_back() 函数：

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);           //如果没有备用空间，则调用_M_insert_aux()
}

push_back() 与 insert() 都有调用_M_insert_aux() 的情况，二者不同的是，push_back()
只从尾端插入元素，相当于push_back() 是 insert() 函数的一个特例。或许 push_back() 应该定义为：

void push_back(const _Tp& __x)
{
insert(vector<_Tp>::end(), const _Tp& __x);
}

从上面可知，vector 增加（插入）新元素时，如果未超过当时的容量，则还有剩余空间，那么直接添加到最后（插入指定位置），然后调整迭代器，这里的
construct() 前面有介绍，是在已分配好的内存上构造对象，这里已分配好的内存定位到剩余空间的起始位置。如果没有剩余空间了，则会重新配置原有元素个数的两倍空间，然后将原空间元素通过复制的方式初始化新空间，再向新空间增加元素，最后析构并释放原空间。

下面学习 pop_back()
，erase()，clear() 等函数的内部实现：

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);  //复制last后面的元素到待擦除段
destroy(__i, _M_finish);                          //擦除后面,清楚 __i 的位置
_M_finish = _M_finish - (__last - __first);     //调整迭代器位置
return __first;
}

void clear() { erase(begin(), end()); }

下面给出局部区间的 erase() 操作图（《STL 源码剖析》）



这里继续学习 insert() 的另一个版本，往指定位置插入 n 个指定元素：insert(position, n, x)

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)  //插入元素个数不为 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) {              //插入位置后面的元素个数 N 大于插入元素的个数 n，N>n
uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);  //将尾端前面的n个元素复制到尾端后面
_M_finish += __n;                            //调整尾端位置

//逆向复制，将插入位置position后面的 N-n 个元素复制到原尾端位置前面
//这样，插入位置后面的均复制到了最后，留下 n 个空间供插入
copy_backward(__position, __old_finish - __n, __old_finish);
fill(__position, __position + __n, __x_copy);     //往插入位置后填进 n 个指定元素
}
else {   //插入位置后面的元素个数 N 不大于 插入元素个数，N<=n
uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);//尾端位置后面填进 n-N 个元素
_M_finish += __n - __elems_after;                //调整尾端位置到原尾端位置后面第 n-N 个位置
uninitialized_copy(__position, __old_finish, _M_finish);  //将插入位置后的元素复制到调整后的尾端位置后
_M_finish += __elems_after;                      //调整尾端位置
fill(__position, __old_finish, __x_copy);      //插入位置到原尾端位置N个元素赋值，前面已赋值n-N个
}
}
else {   //备用空间不足情况，需要重新分配空间
const size_type __old_size = size();   //原空间元素个数
//原空间个数 + 原空间个数与插入个数的较大值，保证可容纳新插入元素
const size_type __len = __old_size + max(__old_size, __n);
iterator __new_start = _M_allocate(__len);               //分配空间
iterator __new_finish = __new_start;

__STL_TRY{
__new_finish = uninitialized_copy(_M_start, __position, __new_start);//原空间插入位置前的元素拷贝到新空间
__new_finish = uninitialized_fill_n(__new_finish, __n, __x);  //填补 n 个元素
__new_finish = uninitialized_copy(__position, _M_finish, __new_finish); //复制原空间插入位置后的元素
}  //如果中间有失败操作，则析构元素并释放新分配的空间
__STL_UNWIND((destroy(__new_start, __new_finish), _M_deallocate(__new_start, __len)));

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

下面给出 insert() 各种情况下的操作图







最后再学习 resize()，reserve() 和 swap()函数的内部实现

//将vector大小重置为 __new_size
void resize(size_type __new_size, const _Tp& __x)
{
if (__new_size < size())           //如果新空间大小小于原空间
erase(begin() + __new_size, end());  //则只保留前面 __new_size 个元素
else
insert(end(), __new_size - size(), __x); //如果新空间大一些，则将大于的部分置为指定值
}

//预留至少共容纳 __n 个元素的空间
vector<_Tp, _Alloc>& operator=(const vector<_Tp, _Alloc>& __x);
void reserve(size_type __n) {
if (capacity() < __n) {           //当前容量小于需要预留的空间时，才进行以下操作
const size_type __old_size = size();    //记录元素个数
//分配__n大小的空间，然后将原空间元素复制初始化
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;
}
}

//交换两个 vector 中的元素
//其实就是交换彼此的迭代器指向位置（迭代器的巧妙功能）
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);
}