寫在前面：
以前競賽只是會用vector的接口函數，這次深入了解下
參考博客：https://www.cnblogs.com/IamTing/p/4605820.html
vector源碼摘錄：
無空間配置器部分
#include<iostream> using namespace std; #include<memory.h> // alloc是SGI STL的空間配置器 template <class T, class Alloc = alloc> class vector { public: // vector的嵌套類型定義,typedefs用於提供iterator_traits<I>支持 typedef T value_type; typedef value_type* pointer; typedef value_type* iterator; typedef value_type& reference; typedef size_t size_type; typedef ptrdiff_t difference_type; protected: // 這個提供STL標准的allocator接口 typedef simple_alloc <value_type, Alloc> data_allocator; iterator start; // 表示目前使用空間的頭 iterator finish; // 表示目前使用空間的尾 iterator end_of_storage; // 表示實際分配內存空間的尾 void insert_aux(iterator position, const T& x); // 釋放分配的內存空間 void deallocate() { // 由於使用的是data_allocator進行內存空間的分配, // 所以需要同樣使用data_allocator::deallocate()進行釋放 // 如果直接釋放, 對於data_allocator內部使用內存池的版本 // 就會發生錯誤 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 max_size() const { return size_type(-1) / sizeof(T); } // 返回重新分配內存前最多能存儲的對象個數 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不分配內存空間 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(const vector<T, Alloc>& x) { start = allocate_and_copy(x.end() - x.begin(), x.begin(), x.end()); finish = start + (x.end() - x.begin()); end_of_storage = finish; } ~vector() { // 析構對象 destroy(start, finish); // 釋放內存 deallocate(); } vector<T, Alloc>& operator=(const vector<T, Alloc>& x); // 提供訪問函數 reference front() { return *begin(); } reference back() { return *(end() - 1); } void push_back(const T& x) { // 內存滿足條件則直接追加元素, 否則需要重新分配內存空間 if (finish != end_of_storage) { construct(finish, x); ++finish; } else insert_aux(end(), x); } iterator insert(iterator position, const T& x) { size_type n = position - begin(); if (finish != end_of_storage && position == end()) { construct(finish, x); ++finish; } else insert_aux(position, x); return begin() + n; } iterator insert(iterator position) { return insert(position, T()); } void pop_back() { --finish; destroy(finish); } iterator erase(iterator position) { if (position + 1 != end()) copy(position + 1, finish, position); --finish; destroy(finish); return position; } iterator erase(iterator first, iterator last) { iterator i = copy(last, finish, first); // 析構掉需要析構的元素 destroy(i, finish); finish = finish - (last - first); return first; } // 調整size, 但是並不會重新分配內存空間 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()); } void clear() { erase(begin(), end()); } protected: // 分配空間, 並且復制對象到分配的空間處 iterator allocate_and_fill(size_type n, const T& x) { iterator result = data_allocator::allocate(n); uninitialized_fill_n(result, n, x); return result; } template <class T, class Alloc> void insert_aux(iterator position, const T& x) { if (finish != end_of_storage) // 還有備用空間 { // 在備用空間起始處構造一個元素，並以vector最后一個元素值為其初值 construct(finish, *(finish - 1)); ++finish; T x_copy = x; copy_backward(position, finish - 2, finish - 1); *position = x_copy; } else // 已無備用空間 { const size_type old_size = size(); const size_type len = old_size != 0 ? 2 * old_size : 1; // 以上配置元素：如果大小為0，則配置1（個元素大小） // 如果大小不為0，則配置原來大小的兩倍 // 前半段用來放置原數據，后半段准備用來放置新數據 iterator new_start = data_allocator::allocate(len); // 實際配置 iterator new_finish = new_start; // 將內存重新配置 try { // 將原vector的安插點以前的內容拷貝到新vector new_finish = uninitialized_copy(start, position, new_start); // 為新元素設定初值 x construct(new_finish, x); // 調整水位 ++new_finish; // 將安插點以后的原內容也拷貝過來 new_finish = uninitialized_copy(position, finish, new_finish); } catch(...) { // 回滾操作 destroy(new_start, new_finish); data_allocator::deallocate(new_start, len); throw; } // 析構並釋放原vector destroy(begin(), end()); deallocate(); // 調整迭代器，指向新vector start = new_start; finish = new_finish; end_of_storage = new_start + len; } } template <class T, class Alloc> void insert(iterator position, size_type n, const T& x) { // 如果n為0則不進行任何操作 if (n != 0) { if (size_type(end_of_storage - finish) >= n) { // 剩下的備用空間大於等於“新增元素的個數” T x_copy = x; // 以下計算插入點之后的現有元素個數 const size_type elems_after = finish - position; iterator old_finish = finish; if (elems_after > n) { // 插入點之后的現有元素個數 大於 新增元素個數 uninitialized_copy(finish - n, finish, finish); finish += n; // 將vector 尾端標記后移 copy_backward(position, old_finish - n, old_finish); fill(position, position + n, x_copy); // 從插入點開始填入新值 } else { // 插入點之后的現有元素個數 小於等於 新增元素個數 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); } } else { // 剩下的備用空間小於“新增元素個數”（那就必須配置額外的內存） // 首先決定新長度：就長度的兩倍 ， 或舊長度+新增元素個數 const size_type old_size = size(); const size_type len = old_size + max(old_size, n); // 以下配置新的vector空間 iterator new_start = data_allocator::allocate(len); iterator new_finish = new_start; __STL_TRY { // 以下首先將舊的vector的插入點之前的元素復制到新空間 new_finish = uninitialized_copy(start, position, new_start); // 以下再將新增元素（初值皆為n）填入新空間 new_finish = uninitialized_fill_n(new_finish, n, x); // 以下再將舊vector的插入點之后的元素復制到新空間 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(start, finish); deallocate(); start = new_start; finish = new_finish; end_of_storage = new_start + len; } } } };
本文章是筆者學習《STL源碼剖析》的學習筆記，記錄的是筆者的個人理解，因為個人的水平有限，難免會有理解不當的地方，而且該書出版的時間比較久，難免會有些不一樣。如有不當，歡迎指出。
vector是c++中經常用到的數據結構，而且在面試時也會有提及，因此了解vector很重要。
一說到vector，我們就很容易想到另外一個與它十分相似的數據結構，關於它們之間顯著的差別，我覺得是在於空間運用的靈活性上。數組是靜態的，在聲明的時候就要指明其具體的空間大小，而vector是動態的，隨着元素的增加，它內部機制會自行擴充以容納新元素。
這里提及一個問題。
1 #include <iostream>
2
3 int main() {
4 int len;
5 std::cin >> len;
6 int arr[len];
7 return 0;
8 }
如上的一小段代碼，在VS中編譯會報錯，而在g++編譯器中卻能順利通過，這里個人不是很理解，或許是跟編譯器內部的編譯規則有關系。
平時，我們要使用vector的時候，聲明如下
std::vector<int> vec0;
std::vector<int> vec1(10);
std::vector<int> vec2(10, 0);
這短短的一句代碼中，到底是做了些什么呢？
我們還是先看看書中給出的部分代碼吧。
1 template <class T, class Alloc = alloc>
2 class vector {
3
4 ...
5
6 protected:
7 typedef simple_alloc<value_type, Alloc> data_allocator;
8 iterator start; //表示目前使用空間的頭
9 iterator finish; //表示目前使用空間的尾
10 iterator end_of_storage; //表示目前可用空間的尾
11
12 void fill_initialize(size_type n, const T& value) {
13 start = allocate_and_fill(n, value);
14 finish = start + n;
15 end_of_storage = finish;
16 }
17
18 // 分配空間並填滿內容
19 iterator allocate_and_fill(size_type n, const T& x) {
20 iterator result = data_allocator::allocate(n);
21 uninitialized_fill_n(result, n, x);
22 return result;
23 }
24
25 ...
26
27 public:
28 vector() : start(0), finish(0), end_of_storage(0) {}
29 vector(size_type n, const T& value) {fill_initialize(n, value);}
30 vector(int n, const T& value) {fill_initialize(n, value);}
31 vector(long n, const T& value) {fill_initialize(n, value);}
32 explicit vector(size_type n) {fill_initialize(n, T());}
33 ...
34 }
上述中可以看到vector部分構造函數，其中默認構造函數只是把所有的迭代器都初始化為０，這是最簡單的了，但注意它並沒有申請內存空間。另外４個大同小異，都向堆申請了大小為n的內存空間，只是初始化這些空間的時候進行的操作不一樣而已：３個用傳入的形參來進行初始化，１個用T類型的值初始化T()來進行初始化。這４個構造函數都用同一個函數fill_initialize()來進行堆空間的申請並且初始化。現在讓我們看看這個函數到底干了些什么。
void fill_initialize(size_type n, const T& value) {
start = allocate_and_fill(n, value);
finish = start + n;
end_of_storage = finish;
}
這個函數不難理解，它要做的工作主要是初始化迭代器。它接受兩個參數n和value，n指明了要申請的堆空間大小，value指明了要初始化這些堆空間的內容，並把它們傳給另外一個函數allocate_and_fill() ,該函數才是真正的申請堆空間和初始化。接着fill_initialize()就根據allocate_and_fill() 返回的迭代器來初始化start迭代器，並且初始化finish和end_of_storage迭代器。
以下再讓我們看看allocate_and_fill() 函數。
// 分配空間並填滿內容
iterator allocate_and_fill(size_type n, const T& x) {
iterator result = data_allocator::allocate(n);
uninitialized_fill_n(result, n, x);
return result;
}
從函數的名字我們都可以大概知道它是要干什么的了。它接受來自fill_initialize()的兩個參數，該兩個參數的含義在前面已提及。然后申請堆空間並初始化。data_allocator實質上就是simple_alloc<value_type, Alloc>，simple_alloc是SGI STL的空間配置器，SGI STL的空間配置器的簡單介紹請點這里或自行谷歌。若果是SGI STL第一級配置器那么data_allocator::allocate()實質上就是直接調用c語言中的malloc()來申請堆空間；若是第二級配置器，就先考察申請區塊是否大於128bytes，若是大於則轉調用第一級配置器，否則就以內存池來管理，目的是為了避免太多小額區塊造成內存碎片化。
在講完data_allocator::allocate()后，我們不妨看看uninitialized_fill_n()，它定義在<stl_uninitialized.h>中。<stl_uninitialized.h>定義了一些全局函數，如uninitialized_fill_n()，用來填充或復制大塊內存數據，以便提高效率。
template<class ForwardIterator, class SIze, class T> ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
迭代器first指向將要初始化空間的起始處；n表示將要初始化空間的的大小；x表示初始化的值。如果[first，first+n)范圍內的每一個迭代器都指向未初始化的內存，那么uninitialized_fill_n()會調用copy constructor，在該范圍內產生x的副本，但注意一點是在此過程中若任何一個copy constructor丟出異常，uninitialized_fill_n()必須析構已產生的所有元素。
說完vector的構造，那么就先看看析構函數吧。
... ...
~vector() {
destroy(start, finish);
dellocate();
}
... ...
析構函數很簡單，就調用兩個函數:destroy()和dellocate()。destroy()負責對象的析構，這個下面將要講述。dellocate()負責釋放申請的堆空間。這里釋放的方式又與空間配置器相關。若果是第一級配置器，就直接調用c語言中free()函數，這正如申請時的簡便。但若果是第二級配置器，則比較復雜一些，具體請參考這里或自行谷歌。
上面的內容就是關於vector申請和釋放堆空間的大概過程，但僅僅是申請和釋放堆空間而已。
為了能繼續下去，我們來看看下面的代碼。
class Foo {..};
Foo* pf = new Foo; // 分配內存，然后構造對象
delete pf; // 將對象析構，然后釋放內存
上述的new操作符做了兩件事:(1)分配內存(2)調用Foo::Foo()構造對象。
同樣，delete操作符也做了兩件事:(1)調用Foo::~Foo()將對象析構(2)釋放內存
但是，在STL 配置器中為了精密分工，把這些操作都細分開來。具體來說就是
::construct()負責對象的構造
::destroy()負責對象的析構
alloc::allocate()負責內存分配
alloc::deallocate()負責內存釋放
上面vector的內存操作所用到就是alloc::allocate()，alloc::deallocate()，這里就不在講述了。
construct()和destroy()都包含在<stl_construct.h>內。
// 這是construct()函數
template <class T1, class T2>
inline void construct(T1* p, const T2& value) {
new (P) T1(value); // placement new;調用T1::T1(value)
}
上述construct()接受一個指針p和一個初值value，該函數的用途就是將初值拷貝一份到指針所指的空間上，這個還是簡單明了的。
接着是destroy()。這個函數有兩個版本，先看第一個版本。
// 第一個版本
template <class T> inline void destroy(T* pointer) { pointer->~T(); }
第一個版本接受一個指針，調用析構函數將該指針所指的對象析構。
// 第二個版本
template<class ForwardIterator, class T>
inline void destroy(ForwardIterator first, ForwardIterator last, T*) {
__destroy(first, last, value_type(first));
}
第二版本接受first和last兩個迭代器，將[first, last)范圍內的所有對象析構掉。這里還要考慮效率問題，但代碼上不再展開。
好了，對對象的構建和析構的過程有了基本的認識后，再看看vector的push_back()函數的實現吧
1 void push_back(const T& x) {
2 if (finish != end_of_storage) {
3 construct(finish, x);
4 ++finish;
5 } else {
6 insert_aux(end(), x);
7 }
8 }
當我們把元素push_back到vector的尾端后，函數首先檢查是否還有備用的空間，如果有的話就調用construct()函數，在finish迭代器指定的位置上構建x對象，同時改變finish迭代器，使其自增１。
然而若果沒有備用空間，就需要擴充空間了，這就是insert_aux()函數所要做的。
1 template <class T, class Alloc>
2 void insert_aux(iterator position, const T& x)
3 {
4 if (finish != end_of_storage) // 還有備用空間
5 {
6 // 在備用空間起始處構造一個元素，並以vector最后一個元素值為其初值
7 construct(finish, *(finish - 1));
8 ++finish;
9 T x_copy = x;
10 copy_backward(position, finish - 2, finish - 1);
11 *position = x_copy;
12 }
13 else // 已無備用空間
14 {
15 const size_type old_size = size();
16 const size_type len = old_size != 0 ? 2 * old_size : 1;
17 // 以上配置元素：如果大小為0，則配置1（個元素大小）
18 // 如果大小不為0，則配置原來大小的兩倍
19 // 前半段用來放置原數據，后半段准備用來放置新數據
20
21 iterator new_start = data_allocator::allocate(len); // 實際配置
22 iterator new_finish = new_start;
23 // 將內存重新配置
24 try
25 {
26 // uninitialized_copy()的第一個參數指向輸入端的起始位置
27 // 第二個參數指向輸入端的結束位置（前閉后開的區間)
28 // 第三個參數指向輸出端(欲初始化空間)的起始處
29
30 // 將原vector的安插點以前的內容拷貝到新vector
31 new_finish = uninitialized_copy(start, position, new_start);
32 // 為新元素設定初值 x
33 construct(new_finish, x);
34 // 調整已使用迭代器的位置
35 ++new_finish;
36 // 將安插點以后的原內容也拷貝過來
37 new_finish = uninitialized_copy(position, finish, new_finish);
38 }
39 catch(...)
40 {
41 // 回滾操作
42 destroy(new_start, new_finish);
43 data_allocator::deallocate(new_start, len);
44 throw;
45 }
46 // 析構並釋放原vector
47 destroy(begin(), end());
48 deallocate();
49
50 // 調整迭代器，指向新vector
51 start = new_start;
52 finish = new_finish;
53 end_of_storage = new_start + len;
54 }
55 }
從代碼中可以知道，當備用空間不足時，vector做了以下的工作：
- 重新分配空間(15~22行)：若原來的空間大小為0，則擴充空間為１，否則擴充為原來的兩倍。
- 移動數據（31～37行）
- 釋放原空間（47～48行）
- 更新迭代器（51～53行)
當調用默認構造函數構造vector時，其空間大小為0，但當我們push_back一個元素到vector尾端時，vector就進行空間擴展，大小為１，以后每當備用空間用完了，就將空間大小擴展為原來的兩倍。
注意的是，所謂動態增加大小，並不是在原空間之后接續新空間，（因為無法保證原空間之后上有可供分配的空間），而是以原大小的兩倍來另外分配一塊較大空間，因此，一旦空間重新分配，指向原vector的所有迭代器就會失效，這里要特別注意。
總結：
vector的各種操作其實離不開四個操作 堆內存的申請和釋放 對象的創建和摧毀
我們在使用vector的時候 應該處理好初始大小問題 vector雖然為動態數組 但是它調整大小的代價很大
所謂動態調整大小，並不是在原vector后面添加新空間，而是申請兩倍長度的vector新空間 然后將原本vector數據復制到新vector上。
對vector的任何操作 如果引起了新的空間配置 那么指向vector的所有迭代器都會失效了