STL学习笔记--4、序列式容器之vector

常见的数据结构：array数组，list链表，tree树，stack栈，queue队列，hash table散列表，set集合，map映射……

根据数据在容器中的排列分为：序列式sequence和关联式associative。

序列式容器之vector

1、vector VS array：

array是静态空间，一旦配置则无法改变；

vector是动态空间，随着元素的加入，内部机制会自动扩充新的空间来容纳新的元素。

实现技术：对大小的控制和重新配置时的数据移动效率。

扩充空间：配置新空间、数据移动、释放旧空间。

2、定义摘要：

在SGI中，

#include<stl_vector.h>

在STl标准中只需要

#include<vector>

template <class T, class Alloc = alloc>
class vector {
public:
//嵌套型别定义
typedef T value_type;
typedef value_type* pointer;
//迭代器类型为随机存取类型
//RandomAccessIterator
typedef value_type* iterator;
typedef value_type& reference;
typedef size_t size_type;

protect:
//方便以元素为单位配置大小
typedef simple_alloc<value_type, Alloc> data_allocator;

//表示目前使用的空间头
iterator start;
//表示目前使用的空间尾
iterator finish;
//表示目前可用的空间尾
iterator end_of_storage;

//插入元素。有备用空间直接插入，无备用空间则进行空间分配
void insert_aux(iterator position, const T& x);

//调用全局deallocate来完成
void deallocate() {
if (start)
data_allocator::deallocate(start,end_of_storage - start);
}

void fill_initialize(size_type n, const T& value)
{
start = allocate_and_fill(n, value);
finish = start + n;
end_of_storage = finish;
}
public:
iterator begin() { return start; }
iterator end() { return finish; }
//容器使用的长度
size_type size() const {
return size_type(end() - begin());
}
//容器可用的长度
size_type capacity() const {
return size_type(end_of_storage - begin());
}

bool empty() const { return begin() == end(); }
reference operator[](size_type n) { return *(begin() + n); }

//构造函数
//默认构造函数
vector() : start(0), finish(0), end_of_storage(0) {}

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

//析构函数
~vector() {
destroy(start, finish);
deallocate();
}

//第一个元素引用
reference front() { return *begin(); }
//最后一个元素引用
reference back() { return *(end() - 1); }

//push_back，调用了insert_aux
void push_back(const T& x) {
if (finish != end_of_storage) {//还有备用空间
construct(finish, x);
++finish;
}
else//以无备用空间
insert_aux(end(), x);
}

//pop_back()
void pop_back() {
--finish;
destroy(finish);
}

//erase版本一：接受一个迭代器
iterator erase(iterator position) {
if (position + 1 != end())
copy(position + 1, finish, position);
--finish;
destroy(finish);
return position;
}
//erase版本二：接受二个迭代器。清除迭代器范围的元素
iterator erase(iterator first, iterator last) {
iterator i = copy(last, finish, first);
destroy(i, finish);
finish = finish - (last - first);
return first;
}

//resize()：为容器重新定义长度。
//若new_size小于size则，丢弃多余部分
//若new_size大于size则，空出的部分进行T类型的值初始化
void resize(size_type new_size, const T& x) {
if (new_size < size())
erase(begin() + new_size, end());
else
insert(end(), new_size - size(), x);
}

void resize(size_type new_size){resize(new_size, T());}

//clear()清空容器
void clear() { erase(begin(), end()); }

protected:
//配置容器并填满内容，填n个x
iterator allocate_and_fill(size_type n, const T& x) {
iterator result = data_allocator::allocate(n);
__STL_TRY {
uninitialized_fill_n(result, n, x);
return result;
}
__STL_UNWIND(data_allocator::deallocate(result, n));
}

3、vector迭代器

vector维护的是连续线性空间。支持随机存取，迭代器类型为RandomAccessIterator。

4、vector数据结构

//表示目前使用的空间头
iterator start;
//表示目前使用的空间尾
iterator finish;
//表示目前可用的空间尾
iterator end_of_storage;

vector实际配置的大小总是大于等于客户端需求的大小，以备将来的扩充。

增加新元素时，如果超出当时容量，则容量进行两倍扩充；若两倍容量不足时，则扩充足够大的容量。

容量的扩充需要进行：重新配置、元素移动、释放旧空间。

5、构造和内存管理：

vector缺省使用alloc作为空间配置器；

uninitialized_fill_n()

根据第一个参数的型别特性type traits决定算法使用(

__true_type

)fill_n()或是反复调用(

__false_type

)construct()来完成。

//push_back，调用了insert_aux
void push_back(const T& x) {
if (finish != end_of_storage) {//还有备用空间
construct(finish, x);
++finish;
}
else//以无备用空间
insert_aux(end(), x);
}

算法实现：insert_aux(end(), x);

template <class T, class Alloc>
void vector<T, Alloc>::insert_aux(iterator position, const T& x) {
if (finish != end_of_storage) {//还有备用空间
//在备用空间起始处构造元素，以finish - 1位置处的值作为初值
construct(finish, *(finish - 1));
++finish;
T x_copy = x;
//将[position,finish-2)处的值拷贝到[(finish - 1)-((finish - 2)-(position)),finish - 1)
copy_backward(position, finish - 2, finish - 1);
*position = x_copy;
}
else {//无备用空间
const size_type old_size = size();
//确定新构造的空间的长度
//若旧空间为0，则构造1个
//若旧空间非零，则构造旧空间的两倍
const size_type len = old_size != 0 ? 2 * old_size : 1;

iterator new_start = data_allocator::allocate(len);
iterator new_finish = new_start;

__STL_TRY {
//旧空间的元素拷贝到新空间
new_finish = uninitialized_copy(start, position, new_start);
//新元素指定为x
construct(new_finish, x);
//调整使用空间大小
++new_finish;
//新元素装入
new_finish = uninitialized_copy(position, finish, new_finish);
}

#ifdef  __STL_USE_EXCEPTIONS
//若新空间分配失败，则释放所有新分配的空间
catch(...) {
destroy(new_start, new_finish);
data_allocator::deallocate(new_start, len);
throw;
}
#endif /* __STL_USE_EXCEPTIONS */

//释放旧空间
destroy(begin(), end());
deallocate();

//调整迭代器，指向新空间
start = new_start;
finish = new_finish;
end_of_storage = new_start + len;
}
}

6、元素操作：erase()

两个参数版本，释放局部区间的清除操作示意图：

7、元素操作：insert()

insert(iterator position, size_type n, const T& x)

1、若备用空间大于等于新增元素个数
(end_of_storage-finish) >= n

计算插入点之后现有的元素个数
elems_after=finish-position;

情况一：1)、若**插入点之后的现有元素个数**大于**新增元素个数**
elems_after>n
{
uninitialized_copy(finish - n, finish, finish);
finish += n;
copy_backward(position, old_finish - n, old_finish);
fill(position, position + n, x_copy);
}

情况二：2)、若**插入点之后的现有元素个数**小于等于**新增元素个数**
elems_after<=n
{
uninitialized_fill_n(finish, n - elems_after, x_copy);
finish += n - elems_after;
uninitialized_copy(position, old_finish, finish);
finish += elems_after;
fill(position, old_finish, x_copy);
}
2、若备用空间小于新增元素个数
(end_of_storage-finish) < n

1)决定新的长度。旧长度的两倍或旧长度+新增元素个数。
len=old_size+max(old_size,n)

2)配置内存空间
iterator new_start =data_allocator::allocate(len);
iterator new_finish = new_start;

情况三：3)数据元素的移动
{
//旧空间的插入点之前的元素copy到新空间
new_finish = uninitialized_copy(start, position, new_start);
//新增的元素初值为x，填入到新空间
new_finish = uninitialized_fill_n(new_finish, n, x);
//旧空间的插入点之后的元素copy到新空间
new_finish = uninitialized_copy(position, finish, new_finish);
}

3、如果分配新空间出现异常，则销毁新分配的内存，抛出异常
# ifdef  __STL_USE_EXCEPTIONS
catch(...) {
destroy(new_start, new_finish);
data_allocator::deallocate(new_start, len);
throw;
}
#endif /* __STL_USE_EXCEPTIONS */

4、清除并释放旧空间内存
destroy(start, finish);
deallocate();

5、调整迭代器，指向新空间
start = new_start;
finish = new_finish;
end_of_storage = new_start + len;

情况一：备用空间充足，且elems_after>n

n=2; elems_after=2; 备用空间end_of_storage-finish=2;

情况二：备用空间充足，且elems_after<=n

n=4; elems_after=2; 备用空间end_of_storage-finish=3;

情况三：备用空间不足容纳新增元素

n=3; 备用空间end_of_storage-finish=2;