有【insert】，那一定少不了【erase】，我们继续来看看
- 对于【erase】来说，我们也是需要先去挪动数据的，但是在这里呢我们需要从前往后挪，也是防止造成覆盖的情况
具体代码如下：
void erase(iterator pos) { assert(pos >= _start && pos < _finish); iterator end = pos + 1; // 移动覆盖 while (end != _finish) { *(end - 1) = *end; ++end; } --_finish; }
立马来测试一下：
💬 对于【insert】来说会存在迭代器失效的问题，那对【erase】来说也会有吗？
- 我们立马通过下面的代码来测试一下
void test_vector8() { bit::vector<int> v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); bit::print(v); auto it = v.begin(); v.erase(it); cout << *it << endl; it++; cout << *it << endl; bit::print(v); }
- 运行起来我们可以看到，并没有出现任何的问题，首先去删除了第一个元素，然后再访问到首个位置便是【2】，接下去再去执行
it++并访问的话便是【3】
- 但若是我们将代码换成下面这样的话就会出现问题了
auto it = v.begin() + 3;
- 运行起来可以看到，当我们删除完最后一个元素后再让迭代器后移，就造成了访问越界的问题，出现了随机值的情况
不过呢，上面只是我们使用自己模拟的【vector】，来用用库里的会看会发生什么情况
- 但是呢我们可以看到如果使用库里面的话就会直接造成程序崩溃的问题
💬 上面呢是在VS下的运行结果，之前有说过VS在的STL是【PJ版】，而Linux下则是【SGI版】，所以我们都要去做一个对比
- 可以看到，神奇的事情发生了~ 在Linux下执行同样的两段代码，却没有发生像VS里面那样的报错，甚至在访问越界之后也没有出现随机值的问题，而是【0】
【小结】：
==erase以后，迭代器失效了，不能访问。VS进行强制，访问会直接报错；Linux下则不会==
然后我们再来看一个点
- 下面这个场景是通过迭代器的形式去删除其中的偶数
auto it = v.begin(); while(it != v.end()) { if(*it % 2 == 0) { v.erase(it); } ++it; }
通过运行结果我们可以看出，确实所有的偶数都被删除了
换一个测试用例，我们加一个【2】，然后在删除的时候就发现【2】没有被删干净
再换一个测试用例，我在最后加了一个【6】，运行之后发现报出了Segmentation fault，这是Linux下的段错误问题
我们通过画图来分析一下
- 首先是对于第二种，根据代码来进行走读，当我们删除了第一个【2】后，后面的四个元素就往前移动了一个位置，接着迭代器++后移，就来到了【3】的位置，所以就错过了第2个【2】
- 那对于第三种测试案例，因为最后一个是 偶数 的原因，所以在删除之后迭代器进行了后移，此时呢它已经是越过了
end()的位置，再去判断的话永远都到不了，所以就出现了【Segmentation fault】的问题
💬 那要如何去避免呢？
- 这其实很简单，我们不要让这个迭代器每次都后移就可以了
auto it = v.begin(); while(it != v.end()) { if(*it % 2 == 0) { v.erase(it); } else { ++it; } }
再去打印看一下看看就发现没什么问题了
- 但是呢这段代码如果放到VS上去的话就不一样了，在Linux下确实是不会出现什么问题，但是在VS下还是一样会直接报错，因为VS会进行强制检查，在访问了一次迭代器之后就不可以再继续访问了
💬 此时我们需要去考虑一下【erase】这个接口的详情了
- 我们要看的是这个返回值，其返回值是一个迭代器，而且是刚刚被删除那个元素的下一个位置
iterator erase (const_iterator position);
- 那如果是这样的话我们就可以考虑在每次删除完一个位置的数据后拿返回值接收一下这个所删除元素的下一个位置，那么在下一次继续访问的时候就不会造成修改操作的问题了
it = v.erase(it);
最后【erase】接口的整体代码如下所示：
iterator erase(iterator pos) { assert(pos >= _start && pos < _finish); iterator end = pos + 1; // 移动覆盖 while (end != _finish) { *(end - 1) = *end; ++end; } --_finish; return pos; }
在有了【erase】之后，我们就可以让
pop_back()去复用这个接口了，可以达到尾删的逻辑
void pop_back() { // 复用erase erase(end() - 1); }
- 最后的话再来讲讲【swap】这个接口，很简单，就是去调用库里面的这个模版函数
swap，去一一交换两个对象中的三个成员变量即可。这个接口我下面在讲【赋值重载】时会使用到
void swap(vector<T>& v) { std::swap(_start, v._start); std::swap(_finish, v._finish); std::swap(_end_of_storage, v._end_of_storage); }
5）默认成员函数
讲了这么多，终于能来讲讲默认的成员函数了
- 首先的话一定是构造函数，有参构造是一定要实现的，因为这里的逻辑和
resize()是类似的，因此我们直接去做一个复用即可
// 有参构造 vector(size_t n, const T& val = T()) { resize(n, val); }
- 那我们在构造的时候就可以去做一个初始化了，发现和
v.resize(10, 0)是同样的效果
bit::vector<int> v(10, 0);
💬 那有同学可能会问，三个私有成员变量不需要去做初始化吗？
- 同学，难道你忘了我们在一开始的时候已经给到了它们初始值为
nullptr吗？这个措施就是很好地避免编译器对内置类型不会去做初始化的问题
private: iterator _start = nullptr; iterator _finish = nullptr; iterator _end_of_storage = nullptr;
- 除了上面这种初始化，我再介绍一种方法：那就是使用 迭代器区间
- 这里我们可以去使用循环配合【push_back】接口去做一个初始化
// [first, last) template<class InputIterator> vector(InputIterator first, InputIterator last) { while (first != last) { push_back(*first); ++first; } }
💻第四轮测试 — 双重构造引发调用歧义
接下去，我们马上对这个迭代器区间做的初始化操作去所一个测试
void test_vector6() { bit::vector<int> v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); bit::vector<int> v2(v.begin(), v.end()); string s("abcdef"); bit::vector<int> v2(s.begin(), s.end()); int a[] = { 1,2,3,4 }; bit::vector<int> v2(a, a + 4); }
可以看到，除了去初始化自己【vector】对象的迭代器区间，【string】对象也可以，而且指针也没问题
💬 但此时呢，如果我再去以下面的有参构造进行初始化的话就会出现一些问题
bit::vector<int> v5(10, 1);
可以看到，说是“非法的间接寻址”
- 这里对迭代器
first去进行解引用目的就是为了获取这个位置上的数据，我们在 指针一文 有所提到 只有指针和迭代器可以解引用，基本数据类型不能解引用
💬 但是有同学一定会疑惑说：为什么这里不会去匹配有参构造，而是去匹配的迭代器区间构造呢？
- 在讲 C++模版 的时候，我们有说到过模版参数会去进行自动类型推导，从而匹配最合适函数模版。因为我们在这里所传入的【10】和【1】都是
int类型，但是呢有参构造的第一个形参类型为size_t，并不是最匹配的 - 而迭代器区间初始化其参数类型都是模版参数，所以在匹配的时候它是最优先进行匹配的
那我们该如何去进行预防呢？
- 很简单，我们可以利用在 C++重载函数 中所学习的参数类型不同去另写一个有参构造的重载形式
vector(size_t n, const T& val = T()) { resize(n, val); } vector(int n, const T& val = T()) { resize(n, val); }
通过调试我们可以看出这里在调用的时候就没有歧义了
💬 最后再补充一个小的知识点，作为拓展
- 那我们在写了这个重载函数后要如何去调用对应的无符号类型
size_t呢，此时我们只需要在传递的参数后加上一个u即可，那么编译器在进行识别的时候就会自动将其识别成为无符号整数
bit::vector<int> v6(10u, 6);
一样通过调试来看就可以很清楚
讲完构造函数了，我们来看看拷贝构造
- 首先读者要明确为什么要写拷贝构造，这个我们通过调试来看一下就知道了：很明显可以看到这里只是做了一个浅拷贝，而不是去做了深拷贝
- 所以我们要自己去实现一个深拷贝，逻辑很简单，就不赘述
// 拷贝构造 vector(vector<int>& v) { _start = new T[v.capacity()]; memcpy(tmp, v._start, sizeof(T) * v.size()); _finish = tmp + v.size(); _end_of_storage = tmp + v.capacity(); }
- 但是看到上面这个
memcpy()，你是否会有一种警惕的心理呢，因为我们上面讲到过 vector 对象中存放的是 string数组，在拷贝的过程中会产生浅拷贝的问题，那就不可以去使用这个memcpy()，具体问题间下图
- 所以拷贝构造的正确形式应该是下面这样的
// 拷贝构造 vector(vector<T>& v) { _start = new T[v.capacity()]; //memcpy(_start, v._start, sizeof(T) * v.size()); for (size_t i = 0; i < v.size(); i++) { _start[i] = v._start[i]; } _finish = _start + v.size(); _end_of_storage = _start + v.capacity(); }
- 可以看到，在改成深拷贝后就不会出现类似的问题了
- 当然我们也可以去做一个投机取巧，复用当前已经实现过的接口【reserve】和【push_back】，首先根据所传递进来对象的容量去做一个扩容的逻辑，开出足够多的空间后再将这个对象中的数据一一尾插进当前对象即可
vector(vector<int>& v) { // 根据v的capacity()去开出对应的空间 reserve(v.capacity()); for (size_t i = 0; i < v.size(); i++) { push_back(v[i]); } }
有了拷贝构造，【赋值重载】也少不了
- 还记得我们在上面所实现过的【swap】接口吗，在进行 string模拟 的时候，我们又使用到这么一个巧计，那就是使用 传值传参，首先会去调用一个拷贝构造构造一个临时对象，但是临时对象出了作用域之后肯定是要销毁的
- 此时我们就可以使用【swap】和当前对象去做一个交换，我呢获取到了你里面的内容，你帮我释放了不需要的内容，简直一举两得（==还记得PUA弟弟的故事吗==😆）
// 赋值重载 const vector<T>& operator=(vector<T> v) { swap(v); return *this; }
- 好，我们来调试观察一下。看到在调用赋值重载前就会去 调用拷贝构造
最后的舞台，给到【析构函数】，再怎么花里胡哨，最后最后空间都是要还给操作系统的
~vector() { delete[] _start; _start = _finish = _end_of_storage = nullptr; }
四、总结与提炼
最后来总结一下本文所学习的内容
- 本文我们重点讲到的是STL中的 vector类，首先我们初步认识了这个类，逐个地去了解了它的一些接口函数，包括【默认成员函数】、【访问及遍历操作】、【常见容量操作】、【修改操作】这些，对于 vector 来说它不像 string 那样有一百来个接口，而是只有几十个，我又精简地挑了一些比较重要的来进行详述，我所讲到的希望读者都可以学会使用并且搞懂
- 但是呢，光简单地了解这些接口还不行，我们要 “知其然，知其所以然”，带着读者把常用的接口都模拟实现了一遍，加强了我们对底层的了解，读者也可以试着在阅读完本文后试着自己去实现一遍，加深印象
上就是本文要介绍的所有内容，感谢您的阅读🌹🌹🌹
