STL之vector学习笔记

vector是动态空间，随着元素的加入，它的内部机制会自行扩充空间以容纳新元素。但是它不是单纯地 配置新空间->数据移动->释放旧空间，它实际配置的大小会比客户需求要大一点

SGI STL的vector实现于stl_vector.h中，而不是vector.h中。

//_Alloc是空间配置器
template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc>

----------

typedef _Tp value_type;   //vector的class _Tp的别名为value_type

//定义了各种指针、迭代器、引用的别名
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;

----------
#ifdef __STL_HAS_NAMESPACES
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_M_start;      //表示目前使用空间的头
using _Base::_M_finish;     //表示目前使用空间的尾
using _Base::_M_end_of_storage;   //表示目前可用空间的尾
#endif /* __STL_HAS_NAMESPACES */

----------

vector维护的是一个连续线性空间，支持随机存取，所以vector提供的是Random Access Iterators

使用三个指针来指示整个空间

using _Base::_M_start;      //表示目前使用空间的头
using _Base::_M_finish;     //表示目前使用空间的尾
using _Base::_M_end_of_storage;   //表示目前可用空间的尾

vector的实际可用空间将会比需要的空间大一些，一旦容量等于空间大小，将会将容量扩充两倍

//构造函数
explicit vector(const allocator_type& __a = allocator_type())
: _Base(__a) {}

vector(size_type __n, const _Tp& __value,
const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_finish = uninitialized_fill_n(_M_start, __n, __value); }

explicit vector(size_type __n)
: _Base(__n, allocator_type())
{ _M_finish = uninitialized_fill_n(_M_start, __n, _Tp()); }

vector(const vector<_Tp, _Alloc>& __x)
: _Base(__x.size(), __x.get_allocator())
{ _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); }

//填充并初始化
template <class _Integer>
void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) {
_M_start = _M_allocate(__n);
_M_end_of_storage = _M_start + __n;
_M_finish = uninitialized_fill_n(_M_start, __n, __value);
}

//将元素插到最末端
void push_back(const _Tp& __x) {
//还有备用空间
if (_M_finish != _M_end_of_storage) {
//在备用空间起始处构造一个元素，并以__x为其初值
construct(_M_finish, __x);
++_M_finish;    //调整最后一个值
}
else
//没有备用空间
_M_insert_aux(end(), __x);
}

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);  //在末尾构造一个以__x为初值的元素
++_M_finish;
}
else
_M_insert_aux(__position, __x);
return begin() + __n;
}

template <class _Tp, class _Alloc>
void
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
{
//如果还有备用空间
if (_M_finish != _M_end_of_storage) {
//在备用空间起始位置构造一个元素，以vector最后一个元素的值为初值
construct(_M_finish, *(_M_finish - 1));
++_M_finish;                               //调整最末端
_Tp __x_copy = __x;
//将__position以后的元素后移
copy_backward(__position, _M_finish - 2, _M_finish - 1);
//将__x插入到__position的位置
*__position = __x_copy;
}
else {
//如果没有备用空间
const size_type __old_size = size();
//__old_size不为0，则将容量扩充为原来的两倍
const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
iterator __new_start = _M_allocate(__len);
iterator __new_finish = __new_start;
__STL_TRY {
//将_M_start到__positon的元素复制到新空间
__new_finish = uninitialized_copy(_M_start, __position, __new_start);
//在__position 处构造一个元素，以__x为初值
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;
}
}

//将尾端元素取出
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) {
//将__last到_M_finish的所有元素移动到__first处
iterator __i = copy(__last, _M_finish, __first);
//将__i到_M_finish的所有元素清除
destroy(__i, _M_finish);
_M_finish = _M_finish - (__last - __first);
return __first;
}