《STL源码剖析》深入分析序列式容器——vector

写在最前面：除非必要，否则我们应该尽量选择使用vector，而弃用deque。记住一句话：一切表面皆假象！



vector是动态空间，随着元素的加入，它的内部机制会自行扩充空间以容纳新元素。随便吃进。

（1）vector的空间配置数据结构：

iterator start;            //已使用空间的头
iterator finish;           //已使用空间的尾
iterator end_of_storage;   //目前可用空间的尾    （我们都知道一个vector的容量永远大于或者等于其大小）

       

         利用这三个迭代器便可轻易的提供首位标识、大小、容量、空容器判断、最前端元素值、最后端元素值等机能。



（2）详解vector的动态分配空间：

void push_back(const T& x) {
if (finish != end_of_storage) {     // 还有备用空間
construct(finish, x);   		// 直接在備用空間中建構元素。
++finish;                          	// 調整水位高度
}
else                                // 已無備用空間
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) {    // 還有备用空間
// 在备用空間起始處建構一個元素，并以vector 最後一個元素值為其初值。
construct(finish, *(finish - 1));
// 調整水位。
++finish;

T x_copy = x;
copy_backward(position, finish - 2, finish - 1);     //copy_backward（first, last, result）逆序复制，范围（first-last），起点（result-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;
__STL_TRY {
// 將原vector 的內容拷貝到新 vector。
new_finish = uninitialized_copy(start, position, new_start);
// 為新元素設定初值x
construct(new_finish, x);
// 調整水位。
++new_finish;

// 將安插点的原vector 的備用空間中的內容也拷貝過來（  因为本函数也可能被insert(p ,x)调用  ）
new_finish = uninitialized_copy(position, finish, new_finish);
}

catch(...) {
// "commit or rollback"    //語意：若非全部成功，就一個不留。
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;
}
}

          特别提醒：对vector的任何操作，一旦引起空间的重新配置，指向原来的vector的所有迭代器就都失效了。从上面代码我们也可已看出，所谓动态增加并不是在原空间之后续接新的空间，而是以原大小的“两倍”（看编译器）另外寻觅配置一段较大空间，然后将原来的内容拷贝过来，接着在原内容的后面构造新元素，最后释放原来的空间。也就是说，vector的所谓成长只是个假象，事实上还是三部曲（1）寻觅更大空间；（2）复制原数据；（3）释放源空间。因为有了备用空间，所以减低了这种假象的代价。



（3）详解vector::insert()实现：（从position位置开始，插入n个元素，初始值为X）

// 从 position 開始，安插 n 個元素，元素初值為 x
template <class T, class Alloc>
void vector<T, Alloc>::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);   // std::uninitialized_copy( first, last, newFirst );先直接后移最后N个
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(...) {
// 如有异常发生，实现 "commit or rollback" semantics.
destroy(new_start, new_finish);
data_allocator::deallocate(new_start, len);
throw;
}
#         endif /* __STL_USE_EXCEPTIONS */
// 以下清除並釋放旧的 vector
destroy(start, finish);
deallocate();
// 以下調整水位標記
start = new_start;
finish = new_finish;
end_of_storage = new_start + len;
}
}
}

一、“插入点之后的现有元素个数M”大于 “新增元素个数N”（前提不需要扩充空间）：（1）直接后移最后N个元素；（2）更新finish；（3）从后向前逆序复制剩余的M-N个元素；（4）从插入点开始，插入新值；



二、“插入点之后的现有元素个数M”小于等于 “新增元素个数N”[b]（前提：不需要扩充空间）：[/b]（1）直接在最后位置插入（复制）N-M个要插入的元素；（2）更新finish；（3）把插入点之后的元素复制到新的finish后面；（4）更新finish；（5）插入新值；



             扩充空间以便插入“过多”的元素（备用空间(2)小于「新增元素個數」(3)（那就必須配置额外的内存））：



附录：

VS vector增加空间策略：

size_type _Grow_to(size_type _Count) const
{	// grow by 50% or at least to _Count     （至少增加一个，或者增加50%）
size_type _Capacity = capacity();

_Capacity = max_size() - _Capacity / 2 < _Capacity
? 0 : _Capacity + _Capacity / 2;	// try to grow by 50%
if (_Capacity < _Count)
_Capacity = _Count;
return (_Capacity);
}