STL源码剖析——序列式容器#1 Vector
在学完了Allocator、Iterator和Traits编程之后，我们终于可以进入STL的容器内部一探究竟了。STL的容器分为序列式容器和关联式容器，何为序列式容器呢？就是容器内的元素是可序的，但未必有序。C++本身就提供了一种序列式容器array（即数组），而STL就提供了多种序列式容器，这些容器都是基于常见的数据建构开发出来的，例如vector、list、deque等等。接下来我们将会对STL里的所有序列式容器进行逐一的学习。
本节要学的容器就是我们日常开发中使用最多的vector，vector的数据安排以及操作方式，与array非常相似。两者唯一的区别在于空间运用的灵活性。array是静态空间，配置了其大小就不能被改变，如果空间满了，要换大的，这只能自己手动来：配置新空间，将元素从旧址一一复制过去，再把原来的空间释放。而vector是动态空间，随着元素的加入，它内部会自行扩充空间，进行元素的复制并释放旧空间。所以在使用上，我们更趋向于使用vector而非array，因为不用考虑元素个数的问题，很适合动态元素个数的情况。我们不必因为害怕空间不足而一开始就要求一个大块头的array了。
我们先从vector类里的public部分出发，因为这部分是我们在使用vector时经常接触到的一些接口，从这些接口开始逐渐深挖，探究其里面的运作机制。为了能够更好的了解vector内部，我们把vector的public部分再细分为五个部分学习，分别是vector的迭代器、vector的数据结构、vector的构造与析构、vector的内存管理、vector的元素操作。
Vector的迭代器
1 template <class T, class Alloc = alloc> 2 class vector { 3 public: 4 // 1. 这里是vector的迭代器部分，包含迭代器的各种特性，在上几节中有详解 5 typedef T value_type; // (1) 6 typedef value_type* pointer; // (2) 7 typedef const value_type* const_pointer; 8 typedef const value_type* const_iterator; 9 typedef value_type& reference; // (3) 10 typedef const value_type& const_reference; 11 typedef size_t size_type; 12 typedef ptrdiff_t difference_type; // (4) 13 // 以下，由于vector 所维护的是一个连续线性空间，所以不论其元素类型为何， 14 // 原生指针都可以作为其迭代器而满足所有需求。 15 typedef value_type* iterator; 16 ... 17 }
vector维护的的是一个连续线性的空间，所以不论其元素类型是什么，普通指针都能作为vector的迭代器而满足所有必要条件，因为vector迭代器所需要的操作行为，如operator*，operator->，operator++，operator--，operator+，operator-，operator+=，operator-=，普通指针天生就具备。vector支持随机存取，而普通指针正有着这样的能力。所以vector提供的是Random Access Iterators。例如
vector<int>::iterator it; vector<Shape>::iterator its;
it的类型其实就是int*，its的类型其实就是Shape*。
Vector的数据结构
在讨论Vector数据结构之前，我们可以先看看我们经常用到的一些并与之相关的函数的实现：
1 template <class T, class Alloc = alloc> // 預設使用 alloc 為配置器 2 class vector { 3 public: 4 ... 5 //获取指向首元素的迭代器 6 iterator begin() { return start; } 7 const_iterator begin() const { return start; } 8 9 //获取指向容器末尾的迭代器 10 iterator end() { return finish; } 11 const_iterator end() const { return finish; } 12 //获取容器元素个数 13 size_type size() const { return size_type(end() - begin()); } 14 //获取容器总大小 15 size_type capacity() const { return size_type(end_of_storage - begin()); } 16 //判断容器是否为空 17 bool empty() const { return begin() == end(); } 18 //重载[]运算符，实现随机访问 19 reference operator[](size_type n) { return *(begin() + n); } 20 const_reference operator[](size_type n) const { return *(begin() + n); } 21 // 取出第一個元素內容，可作左值 22 reference front() { return *begin(); } 23 const_reference front() const { return *begin(); } 24 // 取出最後一個元素內容 25 reference back() { return *(end() - 1); } 26 const_reference back() const { return *(end() - 1); } 27 ... 28 }
可以看到在这几个函数中涉及到了几个变量start、finish和end_of_storage，而它们都是迭代器类型iteartor（从返回类型中看出），而对应它们的定义，vector是把它放到了protected部分：
1 protected: 2 ... 3 iterator start; //表示目前使用空间的头 4 iterator finish; //表示目前使用空间的尾，指向最后一个元素的下一位置（空的） 5 iterator end_of_storage; //表示目前可用空间的尾
这三个迭代器是用来管理vector的存储空间的，那么究竟vector的空间是如何的呢？是连续还是不连续的呢？我们可以从上面某些函数定义里获得结论，例如size()或是capacity()，其定义就是两首尾迭代器的相减，可见vector的数据结构就是连续线性空间。而finish与end_of_storage的区别就是：为了降低空间配置时的速度成本（减少因容量不够而多次扩充造成的成本），vector实际配置的大小可能比用户的需求量更大一些，以备将来可能的需求增加。这便是容量（capacity）的概念。一个vector的容量永远大于或等于其大小，一旦容量等于大小，便是满载，下次再有新增元素，整个vector便得另觅居所。
Vector的构造与析构
在创建vector对象时，我们经常用到的一种构造函数是：
vector(size_type n, const T& value) { fill_initialize(n, value); }
例如vector<int> iv(2, 9); ，用的就是上面这个构造函数，它能创建一个具有n个元素其值为value的数组。从其构造函数的定义中能看到，里面仅仅是一个转调用而已，而fill_initialize()又是什么来头呢？我们在protected部分发现了它的踪迹：
1 void fill_initialize(size_type n, const T& value) { 2 start = allocate_and_fill(n, value); // 配置空间并设置空间的首端 3 finish = start + n; //设置使用空间的尾端 4 end_of_storage = finish; //使用总空间的尾端 5 }
我们发现这个函数只是负责初始化容器3个管理空间的迭代器，而真正配置空间的还另有其人：allocate_and_fill()，而它里面又是怎样的？情理之内，我们又是在protected部分找到的它的定义：
1 protected: 2 // 专属空间配置器，每次配置一个元素大小 3 typedef simple_alloc<value_type, Alloc> data_allocator; 4 5 iterator allocate_and_fill(size_type n, const T& x) { 6 iterator result = data_allocator::allocate(n); // 配置n个元素空间 7 __STL_TRY{ 8 // 全局函数，將result所指之未初始化空间设定初值為为x，n个 9 // 定义于 <stl_uninitialized.h>。 10 uninitialized_fill_n(result, n, x); 11 return result; 12 } 13 // "commit or rollback" 語意：若非全部成功，就一个不留。 14 __STL_UNWIND(data_allocator::deallocate(result, n)); 15 }
能看到这个函数分为两部分，一是分配空间：用了在protected部分定义好的一个simple_alloc对象data_allocator，而这个simple_alloc类我们之前在学习空间配置器时已经有所了解，就是一个有四个成员函数的类，而这四个成员函数里面都是转调用（allocate()就是其中之一），调用的是alloc类里面真正负责分配内存的函数，这里不再赘述。在分配完空间后，第二部分就是对刚分配好的空间进行内容的填充，这里用到的一个函数就是uninitialized_fill_n()它的功能是将result所指的未初始化的空间初始化为n个值为x的元素，再往里深究的话，就会发现去到STL的算法世界了（uninitialized_fill_n函数里的仍有转调用的函数fill_n()，其函数定义在了<stl_algobase.h>里），所以我们就到此为止了，知道这个函数的功能就好，而至于这个函数的源码，我打算在之后专门拿一节来学习这个内存处理的基本工具（它是之一）。
至此，我们了解了vector构造函数的调用逻辑就是vector()→fill_initialize()→allocate_and_fill()→allocate()与uninitialized_fill_n()。
Vector的内存管理
我们前面也有提到，当vector容器内部空间已被填满时，再往其加入元素会进行寻找更大的空间，把旧址的内容复制到新空间，再释放旧空间的这么一个过程。我们知道这是在空间已满且再往其加入元素时发生的，那其中的乾坤就应该发生在push_back函数内部。
1 // 在容器尾部增加一个元素 2 void push_back(const T& x) { 3 if (finish != end_of_storage) { // 还有备用空间 4 construct(finish, x); // 直接在备用空间构建元素 5 ++finish; // 调整已使用空间的尾部迭代器 6 } 7 else // 已无备用空间 8 insert_aux(end(), x); 9 }
push_back函数内部会做一个判断，判断此时容器空间是否被填满，如果没有就如常构建；如果满了就转调用另外一个函数insert_aux来处理：
1 template <class T, class Alloc> 2 void vector<T, Alloc>::insert_aux(iterator position, const T& x) { 3 if (finish != end_of_storage) { 4 //这部分负责insert函数的，与push_back无关，因为finish==end_of_storage不会进入这部分 5 construct(finish, *(finish - 1)); 6 ++finish; 7 8 T x_copy = x; 9 copy_backward(position, finish - 2, finish - 1); 10 *position = x_copy; 11 } 12 else { // 已无备用空间 13 const size_type old_size = size(); 14 const size_type len = old_size != 0 ? 2 * old_size : 1; 15 // 以上配置原则：如果原大小为0，则配置 1（个元素大小）； 16 // 如果原大小不为0，则配置原大小的两倍， 17 // 前半段用來放置原内容，后半段准备用來放置新内容。 18 19 iterator new_start = data_allocator::allocate(len); // 实际配置大小 20 iterator new_finish = new_start; 21 __STL_TRY{ 22 // 將原vector 的內容拷贝到新 vector。 23 new_finish = uninitialized_copy(start, position, new_start); 24 // 为新元素设定初值x 25 construct(new_finish, x); 26 27 ++new_finish; 28 //此处也是对应与insert函数的情况的，因为于push_back而言，此时的情况是position(就是end()) == finish 29 new_finish = uninitialized_copy(position, finish, new_finish); 30 } 31 32 # ifdef __STL_USE_EXCEPTIONS 33 catch (...) { 34 // "commit or rollback" 语意：若非全部成功，就一个不留。 35 destroy(new_start, new_finish); 36 data_allocator::deallocate(new_start, len); 37 throw; 38 } 39 # endif /* __STL_USE_EXCEPTIONS */ 40 41 // 析构并释放原vector 42 destroy(begin(), end()); 43 deallocate(); 44 45 // 调整迭代器，指向新vector 46 start = new_start; 47 finish = new_finish; 48 end_of_storage = new_start + len; 49 } 50 }
insert_aux不仅负责在push_back时为其新增空间，也负责在insert时为其新增空间，但由于现在我们讨论的是push_back函数，所以我们先把关于insert函数的部分忽略不谈，等我们学到insert函数时再去讨论。我们可以把insert_aux函数分为3部分：分配新空间、复制并新增内容、析构并释放旧空间。
- 分配新空间
从代码或注释中我们可以了解到vector扩充空间时，其容量的分配原则，那就是如果此时容器容量为0，则配置一个元素大小的空间；如果此时容器不为0（即容器被填满的情况），则配置两倍原来大小的空间。
2. 拷贝旧内容，构建新内容
该函数用了uninitialized_copy函数来完成拷贝旧内容，该函数的功能就是：将一容器某区间的内容[start, position)复制到一未被初始化的空间里（第三个参数的指针指向该区间）。于push_back而言，position就是旧vector的end()，所以就会把整个旧vector复制到新空间里去。然后再利用construct()构建新元素放在旧内容的后面。而uninitialized_copy函数会与uninitialized_fill_n一起放在内存处理的基本工具这一节中学习。
3. 析构并释放旧空间
利用destroy析构，deallocate释放。最后调整管理空间的迭代器指向新vector。
可以看到，所谓的动态增加大小，并不是在原空间之后接续新空间，而是以原大小的两倍另外配置一块更大的空间，然后将原内容拷贝过来，然后才开始在原内容之后构造新元素，并释放元空间。因此，对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有迭代器就都失效了。
Vector的元素操作
vector提供的元素操作有很多，这里只挑几个比较常用的逐一学习，例如pop_back()、erase()、clear()和insert()。
- pop_back()——弹出容器最后一位元素，但切记vector的pop_back()并不返回弹出的元素，要想获取弹出的元素，最好先用back()获取，再用pop_back()弹出。
1 void pop_back() { 2 --finish; //finish是指向最后一个元素的下一位置，所以先自减，指向最后一个元素 3 destroy(finish); //再把它析构 4 }
- erase(iterator first, iterator last)——该函数清除[first, last)中的所有元素。
1 iterator erase(iterator first, iterator last) { 2 iterator i = copy(last, finish, first); //先把后面不在清除范围内的元素，往清除范围内复制，覆盖其内容，获取覆盖后的位置 3 destroy(i, finish); //覆盖后，后面空间的内容已经失去意义，析构之 4 finish = finish - (last - first); //调整已使用空间的尾部迭代器 5 return first; 6 }
- erase(iterator position)——清除某个位置上的元素
1 iterator erase(iterator position) { 2 if (position + 1 != end()) // 如果 p 不是指向最后一个元素 3 copy(position + 1, finish, position);// 將 p 之后的元素一一向前移动 4 5 //并把最后一个元素析构 6 --finish; 7 destroy(finish); 8 return position; 9 }
copy函数的功能是将[position+1, finish)区间的元素复制到position指向位置上，与uninitialized_copy的区别就是，前者是复制到已经有内容的空间上（覆盖），后者是复制到未被初始化的空间上，这个函数的源码跟uninitialized_copy()、uninitialized_fill_n()一起放在内存处理的基本工具这一节中学习。
- insert(iterator position, size_type n, const T& x)——从position开始，插入n个值为x的元素。由于该函数面对不同的情况有不同的处理方式，所以决定分开情况来讲：
第一种情况是，备用空间大于新增元素个数n，此情况下又分文两种情况：一是「安插点之后的现有元素个数」大于「新增元素个数」，二是「安插點之后的现有元素个数」小于等于「新增元素个数」，两种情况的处理方式不同。
「安插点之后的现有元素个数」大于「新增元素个数」:
1 template <class T, class Alloc> 2 void vector<T, Alloc>::insert(iterator position, size_type n, const T& x) { 3 if (n != 0) { // 当 n != 0 才进行以下所有动作 4 if (size_type(end_of_storage - finish) >= n) { 5 // 备用空间大于等于“新增元素个数” 6 T x_copy = x; 7 // 计算安插点之后的元素个数 8 const size_type elems_after = finish - position; 9 iterator old_finish = finish; 10 if (elems_after > n) { 11 // 「安插点之后的现有元素个数」大于「新增元素个数」 12 // 先将尾端倒数「新增元素个数」（即倒数n个）的元素复制到尾端之后 13 uninitialized_copy(finish - n, finish, finish); 14 finish += n; // 將vector 尾端标记后移 15 //从安插点开始，将剩下未被复制的元素倒序复制到旧尾端之前 16 copy_backward(position, old_finish - n, old_finish); 17 //这样从安插点开始，空出了「新增元素个数」的空位能给予安放新值 18 fill(position, position + n, x_copy); // 從安插點開始填入新值 19 } 20 else // 「安插點之后的现有元素个数」小于等于「新增元素个数」 21 ... 22 }
「安插點之后的现有元素个数」小于等于「新增元素个数」：
1 template <class T, class Alloc> 2 void vector<T, Alloc>::insert(iterator position, size_type n, const T& x) { 3 if (n != 0) { // 当 n != 0 才进行以下所有动作 4 if (size_type(end_of_storage - finish) >= n) { 5 // 备用空间大于等于“新增元素个数” 6 T x_copy = x; 7 // 计算安插点之后的元素个数 8 const size_type elems_after = finish - position; 9 iterator old_finish = finish; 10 if (elems_after > n) { 11 // 「安插点之后的现有元素个数」大于「新增元素个数」 12 ... 13 } 14 else { 15 // 「安插點之后的现有元素个数」小于等于「新增元素个数」 16 //计算「新增元素个数」与「安插點之后的现有元素个数」的差值（n - elems_after），并从尾端开始，填充该差值个数的新值元素 17 uninitialized_fill_n(finish, n - elems_after, x_copy); 18 finish += n - elems_after; // 將vector 尾端标记后移 19 //再将「安插點之后的现有元素」全部复制到新尾端之后 20 uninitialized_copy(position, old_finish, finish); 21 finish += elems_after; 22 //这样从安插点开始，空出了「新增元素个数」的空位能给予安放新值 23 fill(position, old_finish, x_copy); 24 } 25 } 26 else { // 备用空间小于“新增元素个数” 27 ... 28 ｝ 29 ... 30 ｝
第二种情况就是：备用空间小于新增元素个数n，处理方式就比上面容易理解多了：
1 template <class T, class Alloc> 2 void vector<T, Alloc>::insert(iterator position, size_type n, const T& x) { 3 if (n != 0) { // 当 n != 0 才进行以下所有动作 4 if (size_type(end_of_storage - finish) >= n) { 5 // 备用空间大于等于“新增元素个数” 6 T x_copy = x; 7 // 计算安插点之后的元素个数 8 const size_type elems_after = finish - position; 9 iterator old_finish = finish; 10 if (elems_after > n) { 11 // 「安插点之后的现有元素个数」大于「新增元素个数」 12 } 13 else { 14 // 「安插點之后的现有元素个数」小于等于「新增元素个数」 15 } 16 else { 17 // 备用空间小于「新增元素个数」 18 // 首先決定新长度：旧长度的两倍，或旧长度+新增元素个数 19 const size_type old_size = size(); 20 const size_type len = old_size + max(old_size, n); 21 // 以下配置新的vector 空间 22 iterator new_start = data_allocator::allocate(len); 23 iterator new_finish = new_start; 24 __STL_TRY{ 25 // 以下首先將旧vector 的安插點之前的元素复制到新空间。 26 new_finish = uninitialized_copy(start, position, new_start); 27 // 以下再將新增元素（初值皆为 n）填入新空间。 28 new_finish = uninitialized_fill_n(new_finish, n, x); 29 // 以下再將旧vector 的安插點之后的元复制到新空间。 30 new_finish = uninitialized_copy(position, finish, new_finish); 31 } 32 # ifdef __STL_USE_EXCEPTIONS 33 catch (...) { 34 // "commit or rollback" semantics. 35 destroy(new_start, new_finish); 36 data_allocator::deallocate(new_start, len); 37 throw; 38 } 39 # endif /* __STL_USE_EXCEPTIONS */ 40 // 以下清除并释放旧的 vector 41 destroy(start, finish); 42 deallocate(); 43 // 以下调整管理空间的迭代器 44 start = new_start; 45 finish = new_finish; 46 end_of_storage = new_start + len; 47 } 48 } 49 }
