跟我学C++中级篇——STL的容器vector
一、顺序容器vector
C++程序员中，如果用到过STL，那么一定肯定用过vector，这个是最常见，最初步的一个数据类型。上一篇提到的array远远比不上它。毕竟那玩意儿相对vector是很久远后才提出来的。在这之前，std::vector承担了多少小菜鸟处理
数组各种问题的最优选方法。不用处理内存，可以删除，任意增加不考虑越界。那简直是一种最单纯质朴的快乐。
如果单纯的只考虑开发目标，而不考虑对内存占用和再分配导致的性能下降，不用考虑删除时迭代器的问题，那么几乎这玩意儿就可以能抵挡住大多数情况下的对数组的使用了，可惜，没有单纯的想法，还是得面对现实。std::vector重载了[]，所以支持类似数组一样的随机访问，你可以简单理解成它就是一个大数组，只不过他更强大，支持迭代器访问和动态处理（删除、增加等），且不需要你担心对内存的处理。
二、源码
std:vector的源码很容易找到，其实你看它代码也不复杂，之所以看上去眼花缭乱的原因不是因为他复杂，而是为了兼容和安全性搞了好多新功能和方法，再加上一些模板本身的技巧。这些都可以暂时忽略过去，重点看重点的相关的函数方法的实现。
向量的构造函数其实就是两部分模板类型名称和分配器，而分配器一般使用默认的分析器类型，这个回头再分配器中再详细分析。
template >
class vector { // varying size array of values
private:
template
friend class _Vb_val;
friend _Tidy_guard;
using _Alty = _Rebind_alloc_t<_Alloc, _Ty>;
using _Alty_traits = allocator_traits<_Alty>;
public:
static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Ty, typename _Alloc::value_type>,
_MISMATCHED_ALLOCATOR_MESSAGE("vector", "T"));
using value_type = _Ty;
using allocator_type = _Alloc;
using pointer = typename _Alty_traits::pointer;
using const_pointer = typename _Alty_traits::const_pointer;
using reference = _Ty&;
using const_reference = const _Ty&;
using size_type = typename _Alty_traits::size_type;
using difference_type = typename _Alty_traits::difference_type;
private:
using _Scary_val = _Vector_val, _Simple_types<_Ty>,
_Vec_iter_types<_Ty, size_type, difference_type, pointer, const_pointer, _Ty&, const _Ty&>>>;
public:
using iterator = _Vector_iterator<_Scary_val>;
using const_iterator = _Vector_const_iterator<_Scary_val>;
using reverse_iterator = _STD reverse_iterator;
using const_reverse_iterator = _STD reverse_iterator;
vector() noexcept(is_nothrow_default_constructible_v<_Alty>) : _Mypair(_Zero_then_variadic_args_t{}) {
_Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
}
explicit vector(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
_Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
}
......
public:
vector& operator=(vector&& _Right) noexcept(noexcept(_Move_assign(_Right, _Choose_pocma<_Alty>{}))) {
if (this != _STD addressof(_Right)) {
_Move_assign(_Right, _Choose_pocma<_Alty>{});
}
return *this;
}
~vector() noexcept {
_Tidy();
#if _ITERATOR_DEBUG_LEVEL != 0
auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
_Delete_plain_internal(_Alproxy, _STD exchange(_Mypair._Myval2._Myproxy, nullptr));
#endif // _ITERATOR_DEBUG_LEVEL != 0
}
......
void push_back(const _Ty& _Val) { // insert element at end, provide strong guarantee
emplace_back(_Val);
}
void push_back(_Ty&& _Val) { // insert by moving into element at end, provide strong guarantee
emplace_back(_STD move(_Val));
}
template
iterator emplace(const_iterator _Where, _Valty&&... _Val) { // insert by perfectly forwarding _Val at _Where
const pointer _Whereptr = _Where._Ptr;
auto& _My_data = _Mypair._Myval2;
const pointer _Oldlast = _My_data._Mylast;
#if _ITERATOR_DEBUG_LEVEL == 2
_STL_VERIFY(
_Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _My_data._Myfirst && _Oldlast >= _Whereptr,
"vector emplace iterator outside range");
#endif // _ITERATOR_DEBUG_LEVEL == 2
if (_Oldlast != _My_data._Myend) {
if (_Whereptr == _Oldlast) { // at back, provide strong guarantee
_Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...);
} else {
auto& _Al = _Getal();
_Alloc_temporary<_Alty> _Obj(_Al, _STD forward<_Valty>(_Val)...); // handle aliasing
// after constructing _Obj, provide basic guarantee
_Orphan_range(_Whereptr, _Oldlast);
_Alty_traits::construct(_Al, _Unfancy(_Oldlast), _STD move(_Oldlast[-1]));
++_My_data._Mylast;
_Move_backward_unchecked(_Whereptr, _Oldlast - 1, _Oldlast);
*_Whereptr = _STD move(_Obj._Storage._Value);
}
return _Make_iterator(_Whereptr);
}
return _Make_iterator(_Emplace_reallocate(_Whereptr, _STD forward<_Valty>(_Val)...));
}
iterator insert(const_iterator _Where, const _Ty& _Val) { // insert _Val at _Where
return emplace(_Where, _Val);
}
iterator insert(const_iterator _Where, _Ty&& _Val) { // insert by moving _Val at _Where
return emplace(_Where, _STD move(_Val));
}
......
void clear() noexcept { // erase all
auto& _My_data = _Mypair._Myval2;
pointer& _Myfirst = _My_data._Myfirst;
pointer& _Mylast = _My_data._Mylast;
_My_data._Orphan_all();
_Destroy(_Myfirst, _Mylast);
_Mylast = _Myfirst;
}
public:
void swap(vector& _Right) noexcept /* strengthened */ {
if (this != _STD addressof(_Right)) {
_Pocs(_Getal(), _Right._Getal());
_Mypair._Myval2._Swap_val(_Right._Mypair._Myval2);
}
}
_NODISCARD _Ty* data() noexcept {
return _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
}
_NODISCARD const _Ty* data() const noexcept {
return _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
}
_NODISCARD iterator begin() noexcept {
auto& _My_data = _Mypair._Myval2;
return iterator(_My_data._Myfirst, _STD addressof(_My_data));
}
_NODISCARD const_iterator begin() const noexcept {
auto& _My_data = _Mypair._Myval2;
return const_iterator(_My_data._Myfirst, _STD addressof(_My_data));
}
_NODISCARD iterator end() noexcept {
auto& _My_data = _Mypair._Myval2;
return iterator(_My_data._Mylast, _STD addressof(_My_data));
}
_NODISCARD const_iterator end() const noexcept {
auto& _My_data = _Mypair._Myval2;
return const_iterator(_My_data._Mylast, _STD addressof(_My_data));
}
_NODISCARD reverse_iterator rbegin() noexcept {
return reverse_iterator(end());
}
_NODISCARD const_reverse_iterator rbegin() const noexcept {
return const_reverse_iterator(end());
}
_NODISCARD reverse_iterator rend() noexcept {
return reverse_iterator(begin());
}
_NODISCARD const_reverse_iterator rend() const noexcept {
return const_reverse_iterator(begin());
}
_NODISCARD const_iterator cbegin() const noexcept {
return begin();
}
_NODISCARD const_iterator cend() const noexcept {
return end();
}
_NODISCARD const_reverse_iterator crbegin() const noexcept {
return rbegin();
}
_NODISCARD const_reverse_iterator crend() const noexcept {
return rend();
}
......
}
其中有大量的简化别名，这个也导致了初学者的看着不“顺眼”。慢慢来，习惯就好。
std::vector是线性的或者说平坦的空间，所以访问它的元素，从理论上讲更容易，也就是前面提到的随机访问。迭代器在线性空间上的应用也只要控制好指针的位置即可，而不强需要指针的迭代性。许多操作看上去挺简单，其实都反复对性能和应用的平衡的结果，这也是为什么有很多人一直说STL的不好的主要原因。一定要搞清楚到底是为什么这么做，明白一个原因，其它也就全通了。学习STL的过程，就是学习C++大牛们的思想的过程，这才是最重要的部分，一定不能念歪了经。
vector的内存管理使用两级策略：
第一级 __malloc_alloc_template内存分配器
此分配器是对malloc、realloc以及free的调用封装；
第二级 __default_alloc_template
其实就是维护一个内存池，一个链表s_free_list可以把这些空闲的内存连接起来，写过内存池或者接触过的一说应该就明白，其大小为16。这16个链表中每个链表中的空闲空间的大小都是固定的8，16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128字节。
那么实际分配就好说了，大于128的使用第一种，否则使用当前内存池中的链表遍历，查找可用空闲找到后直接使用，否则*8，调用refill再次分配。
释放相对就简单了，同样分成两部分，大于128字节转第一个调用free，否则加入回收空闲列表。
template
pointer _Emplace_reallocate(const pointer _Whereptr, _Valty&&... _Val) {
// reallocate and insert by perfectly forwarding _Val at _Whereptr
_Alty& _Al = _Getal();
auto& _My_data = _Mypair._Myval2;
pointer& _Myfirst = _My_data._Myfirst;
pointer& _Mylast = _My_data._Mylast;
_STL_INTERNAL_CHECK(_Mylast == _My_data._Myend); // check that we have no unused capacity
const auto _Whereoff = static_cast(_Whereptr - _Myfirst);
const auto _Oldsize = static_cast(_Mylast - _Myfirst);
if (_Oldsize == max_size()) {
_Xlength();
}
const size_type _Newsize = _Oldsize + 1;
const size_type _Newcapacity = _Calculate_growth(_Newsize);
const pointer _Newvec = _Al.allocate(_Newcapacity);
const pointer _Constructed_last = _Newvec + _Whereoff + 1;
pointer _Constructed_first = _Constructed_last;
_TRY_BEGIN
_Alty_traits::construct(_Al, _Unfancy(_Newvec + _Whereoff), _STD forward<_Valty>(_Val)...);
_Constructed_first = _Newvec + _Whereoff;
if (_Whereptr == _Mylast) { // at back, provide strong guarantee
_Umove_if_noexcept(_Myfirst, _Mylast, _Newvec);
} else { // provide basic guarantee
_Umove(_Myfirst, _Whereptr, _Newvec);
_Constructed_first = _Newvec;
_Umove(_Whereptr, _Mylast, _Newvec + _Whereoff + 1);
}
_CATCH_ALL
_Destroy(_Constructed_first, _Constructed_last);
_Al.deallocate(_Newvec, _Newcapacity);
_RERAISE;
_CATCH_END
_Change_array(_Newvec, _Newsize, _Newcapacity);
return _Newvec + _Whereoff;
}
在c++11中提供了shrink_to_fit()函数，可以减少相关的内存使用，不过需要注意的，一定要看使用后是否引起了迭代器的失效，如果已经失效一定要重新处理迭代器的引用，否则会引起崩溃。
三、例程
std::vector的成员有很多，这里不一一介绍，看一下下面的例程，有什么不明白的直接查相关帮助即可：
#include
#include
#include
void TestAdd()
{
std::vector vec;
vec.push_back(0);
std::cout << "vec size:" << vec.size() << " vec capacity:" << vec.capacity() << std::endl;
vec.emplace(vec.begin(),1);
vec.emplace_back(2);
vec.insert(vec.end(),3);
for (auto v : vec)
{
std::cout << "vec value:" << v << std::endl;
}
vec.resize(100);
std::cout << "vec size:" << vec.size() << " vec capacity:" << vec.capacity() << std::endl;
vec.shrink_to_fit();
std::cout << "vec size:" << vec.size() << " vec capacity:" << vec.capacity() << std::endl;
}
void TestDel()
{
std::vector vec = {0,1,2,3,4,5,6,7,8,9};
std::vector::iterator it = vec.begin();
std::cout << "first is:" << vec.front() << "end is:" << vec.back() << std::endl;
std::cout << "second is:" << vec[1] <<"at three:"<().swap(vec);
for (auto it = vec.begin(); it != vec.end(); it++)
{
std::cout << "vec content:" << *it << std::endl;
}
}
int main()
{
TestAdd();
TestDel();
return 0;
}
运行结果是：
vec size:1 vec capacity:1
vec value:1
vec value:0
vec value:2
vec value:3
vec size:100 vec capacity:100
vec size:100 vec capacity:100
first is:0end is:9
second is:1at three:3
vec content:1
vec content:2
vec content:3
vec content:4
vec content:5
vec content:6
vec content:7
vec content:8
vec content:9
vec content:
四、注意点
使用std::vector需要注意的有以下几点：
1、空间的分配问题
不建议在小内存环境下申请使用较大的vector对象，容易引起内存的不足。前面提到过，如果使用默认的分配器，内存的处理会比实际需要的大好多，特别是做一些插入操作时，遇到临界点会引起重新分配（大约是1.5到2倍）和拷贝，也很耗费时间。
2、自定义对象的操作符重载问题
如果使用自定义对象，因为迭代器的需要，一定在结构体或类中实现对操作符==，=及相关操作符的重载。
3、删除元素时一定要及时获取下一个对象的迭代器
如果想当然的删除，可能会引起崩溃，这个崩溃几回才好，你才能记得更清楚，正所谓“事非经过不知难”，说得再好听，大多数人都得经过几次才长心。
4、添加元素尽量使用emplace_back
原因是可以减少拷贝对象的次数。c++11提供的move语义也提供了更高效的方式。
五、总结
其实写这个STL，就很犹豫，毕竟前面有大神侯捷的STL源码剖析，而应用网上有官方的网站，各种例程都很多并且相当清晰。但是为啥还是写了下来呢，除了是让中级c++篇更完善，另外一个原因是想把更新的一些c++标准的东西揉合进来，不过限于个人的能力，可能会有不少问题，希望看到后，能及时提出来，共同进步。
