SGI STL源码之vector

之前应聘阿里巴巴实习生招聘时遇到一道题，现在还记忆犹新，题目如下：

#include<iostream>
#include<vector>
using namespace std;

int main()
{
	vector<int> v;
	vector<int>::iterator iter;
	v.push_back(200);
	v.push_back(300);
	v.push_back(300);
	v.push_back(400);
	v.push_back(400);
	v.push_back(600);

	for (iter = v.begin(); iter != v.end();iter++)
	{
		if (*iter == 300)
			v.erase(iter);
	}

	for (iter = v.begin(); iter != v.end(); iter++)
		cout << *iter << endl;
}

请问程序运行结果是什么？可以自己想想，答案也许在你看过源码之后你会恍然大悟。

1、简介

vector是序列式容器的一种，其存储方式类似于数组，分配给它的空间是一段连续的内存。与数组不同的是，vector是动态空间，随着元素的不断增加，它的内部机制会自动扩充空间以容纳新的元素，不用担心空间不足的情况。vector的实现技术，关键在于其对大小的控制以及重新分配内存时的移动速率，如果添加一个元素就只分配一个元素大小的内存，实为不智之举，大量重复的“配置新空间/数据移动/释放旧空间”时间成本高，应该加入某种未雨绸缪的考虑。

2、源码剖析

类vector继承自基类_Vector_base，_Vector_base的源码如下：

template <class _Tp, class _Alloc>
class _Vector_base
{
protected:
	_Tp* _M_start;//有效数据的起始位置
	_Tp* _M_finish;//有效数据的结束位置
	_Tp* _M_end_of_storage;//指向最后一个元素的下一位置
public:
	typedef _Alloc allocator_type;
	allocator_type get_allocator() const { return allocator_type(); }

	_Vector_base(const _Alloc&)
		: _M_start(0), _M_finish(0), _M_end_of_storage(0) {}
	_Vector_base(size_t __n, const _Alloc&)
		: _M_start(0), _M_finish(0), _M_end_of_storage(0)
	{
		_M_start = _M_allocate(__n);
		_M_finish = _M_start;
		_M_end_of_storage = _M_start + __n;
	}

	~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }
protected:
	typedef simple_alloc<_Tp, _Alloc> _M_data_allocator;
	_Tp* _M_allocate(size_t __n)
	{
		return _M_data_allocator::allocate(__n);
	}
	void _M_deallocate(_Tp* __p, size_t __n)
	{
		_M_data_allocator::deallocate(__p, __n);
	}
};

_Vector_base类非常简单，主要包含用于指示数据位置的三个数据成员指针和两个构造函数(一个构造函数除了把数据成员初始化为0之外，其它的什么都没做；另一个则是指定n个字节的大小)

<1>vector的迭代器：

迭代器基本上贯穿了整个STL，我将会另外开辟一篇博文来专门介绍迭代器，目前可以 认为迭代器是一种泛型指针，其行为类似于指针，具有操作符*和->等功能。确实在vector的内部迭代器就是普通的指针，仅仅是一个typedef而已，我们来看一下和迭代器相关的操作：

class vector : protected _Vector_base<_Tp, _Alloc>
{
public:
    ....
	typedef _Tp value_type;
	typedef value_type* pointer;
	typedef const value_type* const_pointer;
	typedef value_type* iterator;//此迭代器就是一个普通指针
	typedef const value_type* const_iterator;
	....
public:
	....
	iterator begin() { return _M_start; }
	const_iterator begin() const { return _M_start; }
	iterator end() { return _M_finish; }
	const_iterator end() const { return _M_finish; }
	....
}

既然vector的迭代器是一个常规指针，因此就不用重载++、--、*、->、+、-、+=、-=等操作符，因为常规指针天生就具有这些功能。

<2>在vector容器尾端插入元素：push_back()：当在vector尾端插入元素时，首先会检查是否还有备用空间，如果有备用空间则将元素插入，并调整_M_finish位置；如果没有备用空间，则会重新申请两倍于当前空间的大小，一半用来存储原有数据，另一半用来当做备用空间，因而需要进行申请新空间、移动数据、释放旧空间。

class vector : protected _Vector_base<_Tp, _Alloc>
{
public:
    ....
	void push_back(const _Tp& __x)
	{
		if (_M_finish != _M_end_of_storage) //如果还有备用空间
		{
			construct(_M_finish, __x);//此函数会调用定位new运算符，在指定的位置存储对象
			++_M_finish;
		}
		else//已没有备用空间
			_M_insert_aux(end(), __x);
	}

	....
}

如果没有备用空间则转而调用如下函数：

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();
		//如果原有容量的大小为0，则分配1个字节的大小；否则，则分配的空间为原来的2倍
		const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
		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);
			++__new_finish;
			__new_finish = uninitialized_copy(__position, _M_finish, __new_finish);
		}
		__STL_UNWIND((destroy(__new_start, __new_finish),
			_M_deallocate(__new_start, __len)));
		destroy(begin(), end());//此函数会调用对象的析构函数
		_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;
	}
}

<3>在指定位置插入元素：insert(iterator __pos, size_type __n, const _Tp& __x)：在__pos位置之前插入__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) 
	{
		/*有足够的备用空间*/
		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);
			}
		}
		else //备用空间不够用
		{
			/*申请的备用空间大小为2*__old_size或者为(__old_size+__n)*/
			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
			{
				//复制__position之前的元素到新空间
				__new_finish = uninitialized_copy(_M_start, __position, __new_start);
				//用新增元素的值填充新空间
				__new_finish = uninitialized_fill_n(__new_finish, __n, __x);
				//复制__position之后的元素到新空间
				__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;
		}
	}
}

<4>删除尾端元素：pop_back：将尾端元素删除、并修改尾指针

void pop_back()
{
	--_M_finish;
	destroy(_M_finish);
}

<5>清除某个位置上的元素：

iterator erase(iterator __position)
{
	if (__position + 1 != end())
		copy(__position + 1, _M_finish, __position);
	--_M_finish;
	destroy(_M_finish);
	return __position;
}

从上面的代码我们可以看出，erase函数将__position位置之后的元素向前移动一个位置，并返回__position。看了源代码之后，你是否对阿里笔试题有所醒悟。在Linux下运行的结果如下：

备注：如果是在VS下运行该程序，那么会出现运行时错误，因为VS会将删除位置的指针变为野指针，对野指针进行++操作是不允许的。

vector还有很多其它操作，这里就不做一一介绍了，希望本篇博客能起到抛砖引玉的作用。。。。