前言
作者：小蜗牛向前冲
如果觉的博主的文章还不错的话，还请
点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正。
目录
一、 vector类的基本用法
1、什么是vector
2、vector的基本使用
3、reserve 和resize使用细节
二、刨析迭代器失效
1、引起其底层空间改变导致失效
2、指定位置元素的删除操作--erase导致失效
三、模拟实现vector
1、模拟实现
2、模拟实现中深浅拷贝问题
本期学习目标: 了解vector类的基本用法，刨析迭代器失效问题，刨析深浅拷贝问题，模拟实现vector。
一、 vector类的基本用法
1、什么是vector
简单点来是其实就是一个数组，那这和我们在C语言学习的数组又有什么区别。
下面我们来看到vector的文档介绍：
- vector是表示可变大小数组的序列容器。
- 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素 进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
- 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是 一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
- vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存 储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是 对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
- 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list 统一的迭代器和引用更好。
2、vector的基本使用
对于vector的来是他是一个类，他有自己的成员函数和成员变量，但是这次我们不在一一去为大家分析，大家有不理解的地方可以多多查询文档。(博主一般用cplusplus查询)
我对数据进行操作无法就是对数据进行增删查改，而数组也是要对数据进行处理的，下面我们就一起去见一见vector的增删查改。
| vector增删查改 | 接口说明 |
| push_back（重点） | 尾插 |
| pop_back （重点） | 尾删 |
| find | 查找。（注意这个是算法模块实现，不是vector的成员接口） |
| insert | 在position之前插入val |
| erase | 删除position位置的数据 |
| swap | 交换两个vector的数据空间 |
| operator[] （重点） | 像数组一样访问 |
简单举例：
int main()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
//迭代器遍历
vector<int>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
上面那些增删查改的接口大家多用用就会使用了，但是大家都知道C++的语法是细节特别多的，
下面我们了解一下在使用的时候要注意哪些细节：
3、reserve 和resize使用细节
大家可能会说reserve不就是提前开好空间吗？resize不就是开空间并初始化吗？这哪里有什么细节。下面大家看看一段代码：
void test()
{
vector<int> v;
//开好100个元素的空间
v.reserve(100);
//用[]插入10个元素
for (size_t i = 0;i < 10;++i)
{
v[i] = i;
}
}大家觉的上面代码可行吗？不少小伙伴可能会说没问题，我开好了100个元素的空间，存放10个元素肯定没问题，但事实真的是如此吗？
但是实际上代码崩溃了，还是断错误，这是怎么回事呢?难道我们不能使用我开辟的空间吗？
其实不然，我是可以使用，但是由于在重载[]的时候加了检测是否越界的断言，因为我们用reserve仅仅只是开辟了100个空间，但是size==0，而[]的检测正好是检测size在遍历的时候有没有超过，而刚刚开始数组中的元素为0，而我们却要输入到第10个元素这肯定是不被允许的。
那么当我们要为数组赋值元素怎么办了，就可以用resize初始化好元素个数在进行赋值。
void test3()
{
vector<int> v;
//开好10个元素的空间
v.resize(10);
//用[]插入10个元素
for (size_t i = 0;i < 10;++i)
{
v[i] = i;
}
for (auto ret : v)
{
cout << ret << " ";
}
cout << endl;
}
二、刨析迭代器失效
在很多种情况下vector的迭代器会失效，为什么会失效呢？
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了 封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的 空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器， 程序可能会崩溃)。
1、引起其底层空间改变导致失效
当我们对数组进行增删查改时，会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、 push_back等。
void test4()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
auto it = v.begin();
v.resize(100, 2);//扩间
}
扩容前
扩容后
这里我们可看到当v进行扩容后，他的空间不在是原来的空间进行扩容的而是，进行异地扩容的。但是这时候it他任何指向原来的空间，而原来的空间已经释放，所以他会失效。也就是说当用vector开辟出来的数组在扩容后，有可能会导致迭代器失效。
2、指定位置元素的删除操作--erase导致失效
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代 器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是 没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。
下面继续举个例子：
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int a[] = { 1, 2, 3, 4 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
// 使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
// 删除pos位置的数据，导致pos迭代器失效。
v.erase(pos);
cout << *pos << endl; // 此处会导致非法访问
return 0;
}
当我们进行调试的时候发现程序会崩溃，大家可能会想我这不删除的是3吗?这时pos的应该指向4啊？没问题，但是由于C++的检测机制的原因，这里我们仍然认为pos是失效的。
所以是：只要我们进行了erase操作次迭代器就会失效。
那我们在后面又要用到迭代器怎么办？
其实很简单，我们只要在迭代器失效后在更新一下迭代器就可以了。
三、模拟实现vector
1、模拟实现
为了更好的理解vector的底层实现，下面要模拟实现vector:
这里我们写二个文件，test.cpp用来测试，而vector.h用来实现cector各种功能
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string.h>
#include<assert.h>
#include<algorithm>
using namespace std;
#include"vector.h"
int main()
{
pjb::test2();
return 0;
}test.cpp
#pragma once
namespace pjb
{
template<class T>
class vector
{
public:
//二种版本的迭代器
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish ;
}
const_iterator begin()const
{
return _start;
}
const_iterator end()const
{
return _finish;
}
bool empty()const
{
return _start == _finish;
}
size_t size()const
{
return _finish - _start;
}
size_t capacity()const
{
return _endofstorage - _start;
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];//这里可理解_strart是一个指针
}
T& operator[](size_t pos)const
{
assert(pos < size());
return _start[pos];//这里可理解_strart是一个指针
}
//析构函数
vector()
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}
//拷贝构造v2(v1)
vector(size_t n,const T& val =T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
for (size_t i = 0; i < n;++i)
{
push_back(val);
}
}
//这里是为了解决类型不匹配的问题
//vector<int> v(10,1);
//vector<char>v(10,'A');
vector(int n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
for (int i = 0; i < n;++i)
{
push_back(val);
}
}
//迭代器版本拷贝构造
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}
//析构函数
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
//开内存
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldSize = size();
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * oldSize);//用memcop会出现浅拷贝的问题
for (size_t i = 0;i < oldSize;++i)
{
tmp[i] = _start[i];
}
delete[]_start;//释放原来的空间
}
_start = tmp;
_finish = tmp + oldSize;
_endofstorage = _start + n;
}
}
//开内存并初始化
void resize(size_t n,T val = T ())
{
if (n > capacity())
{
reserve(n);
}
if (n > size())
{
//进行初始化，size后面的空间
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
//删除数据
else
{
_finish = _start + n;
}
}
//重载=
//v1==v2
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
//尾插
void push_back(const T& x)
{
if (_finish == _endofstorage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
*_finish = x;
++_finish;
}
//尾删除
void pop_back()
{
assert(empty());
--_finish;
}
//插入
//迭代器失效
void insert(iterator pos, const T& val)
{
assert(pos < _finish);
assert(pos >= _start);
if (_finish == _endofstorage)
{
//提前算好pos距离_start的距离，好进行更新
size_t len = pos - _start;
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
//这里由于扩容回导致迭代器失效，需要跟更新pos
pos = _start + len;
}
//挪动数据,从后向前挪动
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = val;
++_finish;
}
//交换
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
//清理
void clear()
{
_finish = _start;
}
private:
iterator _start;//指向数组的第1个数据
iterator _finish;//指向数组最后1个元素的下个位置
iterator _endofstorage;//指向容量的位置
};vector.h
2、模拟实现中深浅拷贝问题
其实我们在模拟实现中要考虑很多问题，其中最为重要的是迭代器失效和深浅拷贝问题，迭代器失效的问题前面已经说过了这里就不在多说了，下面我们一起来研究一下深浅拷贝问题。
这里我们来看上面我们模拟实现reserve:
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldSize = size();
T* tmp = new T[n];
if (_start)
{
memcpy(tmp, _start, sizeof(T) * oldSize);
delete[]_start;//释放原来的空间
}
_start = tmp;
_finish = tmp + oldSize;
_endofstorage = _start + n;
}
}分析:
- memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。
- 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。
测试代码：
void test3()
{
vector<vector<int>> vv;
vector<int> v(5, 1);
vv.push_back(v);
vv.push_back(v);
vv.push_back(v);
vv.push_back(v);
vv.push_back(v);//这里多了这里插入就要扩容
for (size_t i = 0; i < vv.size(); ++i)
{
for (size_t j = 0; j < vv[i].size(); ++j)
{
cout << vv[i][j] << " ";
}
cout << endl;
}
cout << endl;
}
不需要扩容
要扩容
这里我们用的是一个二维数组，也就是vector的类型又是一个vector，这里为什么会崩溃，其原来是这里进行了扩容，就要进行空间的拷贝，但这里进行的是浅拷贝，所以就崩溃了。
没扩容前的空间指向
扩容后
这里结合上图我们一起了分析一下为什么一扩容就会崩溃呢？
在扩容前vector<int>*的数组他指向一个空间，这个空间存放了多个vector。
但是当扩容后，vtmp就扩容8空间存放多个vector这是没问题的；但是这里每个vector由于用的是memcpy拷贝的，就会出现浅拷贝现象，也就是tmp中的vector的仍然指向原来的空间，但是当拷贝完后vector的原空间是要被释放的。使用这里程序自然就崩溃了。
那我们怎么解决呢？
其实也很简单，我们只要保证进行二次深拷贝就可以了。
//开内存
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldSize = size();
T* tmp = new T[n];
if (_start)
{
/* memcpy(tmp, _start, sizeof(T) * oldSize);*///用memcop会出现浅拷贝的问题
for (size_t i = 0;i < oldSize;++i)
{
tmp[i] = _start[i];
}
delete[]_start;//释放原来的空间
}
_start = tmp;
_finish = tmp + oldSize;
_endofstorage = _start + n;
}
}这里我们调用对象的赋值就可以解决了。
![[ElasticSearch]-初识Elastic Stack](https://img-blog.csdnimg.cn/317c60c5ca88419194c71d45bdcc373a.png)
![[附源码]Python计算机毕业设计Django的旅游景点管理系统的设计与实现](https://img-blog.csdnimg.cn/1634e9422614420e9b0b4c1a370ea68d.png)
![[附源码]Python计算机毕业设计SSM老年公寓管理系统（程序+LW)](https://img-blog.csdnimg.cn/ff5a15ed42644f229e4df744a5672bdf.png)
