目录
前言
哈喽，小伙伴们大家好。上一篇文章我们介绍了string类，和string一样，vector同样是stl容器的重要组成部分，那么今天就让我们一起来学习一下吧。
一、vector的介绍
1. vector是表示可变大小数组的序列容器。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好
二、vector的使用
1.基本函数接口
vector学习时一定要学会查看文档：vector的文档介绍，vector在实际中非常的重要，在实际中我们熟悉常见的接口就可以，下面列出了哪些接口是要重点掌握的。
vector的函数和string极为相似，具体使用方法我在string的文章中详细介绍，相信大家结合上篇文章还有文档，使用一些基本的函数应该不是问题。
2、迭代器失效
2.1案例一
先介绍一个函数，find函数，包含在头文件<alogrithm>中，只要传迭代器给它，他就会从迭代器范围内搜索特定内容，并返回相应位置的迭代器。如果找不到，则返回末尾的（末尾的迭代器一般不在范围内）
我们看一个代码：
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);
// 3的前面插入一个30
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
if (pos != v.end())
{
v.insert(pos, 30);
}
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
// 删除3
// pos在insert以后就失效了，所以我们不要用他
v.erase(pos);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
这里肯能有两种情况：
情况1：不发生增容，pos的意义变了
pos的意义改变，插入数据后，pos不再指向3，而是指向30，导致删除时没有按照我们的预期删掉3。
情况2：发生增容，程序崩溃
如果插入数据后，恰好赶上vector增容，则会崩溃。因为在增容时，编译器会把原来的空间销毁，去开辟一个新的空间，那么pos就成了野指针，再使用时导致程序崩溃。
想要解决这个问题很简单，只需要在删除之前再调用一次find函数。
// 删除3
// pos在insert以后就失效了，所以我们不要用他
pos = find(v.begin(), v.end(), 3);
if (pos != v.end())
{
v.erase(pos);
}2.2案例二
代码如下：
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);
v.push_back(6);
v.push_back(7);
vector<int>::iterator it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
// erase(it)以后 it失效，不能++，
v.erase(it);
it++;
}
else
{
++it;
}
}
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
该代码运行过程如下，当it指向2时，删除2后，it开始指向3，意义改变，迭代器失效。然后再执行++命令，会直接指向4，等于越过了3的判断。更严重的是，it既然会越过3，在后面就有可能越过v.end(),变成野指针。
解决方法：
while (it != v.end())
{
if (*it % 2 == 0)
{
// erase(it)以后 it失效，不能++，
// erase 会返回删除位置it的下一个位置
it = v.erase(it);
}
else
{
++it;
}
}结论：无论是插入或删除都有可能导致迭代器失效，迭代器失效有两种情况，一是意义改变，二是变成野指针。
三、vector的模拟实现
1、核心框架图例
2、核心框架接口模拟实现
namespace zxy
{
template <class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
//构造函数
vector()
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}
//拷贝构造
vector(const vector<T>& v)
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{
_start=new T[v.capacity()];
/*memcpy(_start,v._start,v.size()*sizeof(T)) 拷贝构造string等自定义类型时，会出问题*/
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}
//析构函数
~vector()
{
delete[] _start;
_start = _finish = _endofstorage=NULL;
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
//赋值运算符重载
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
//判空
bool empty()
{
return _start == _finish;
}
//取开头的迭代器
iterator begin()
{
return _start;
}
//取末尾的迭代器
iterator end()
{
return _finish;
}
//计算存储个数
size_t size() const
{
return _finish - _start;
}
//计算容量
size_t capacity() const
{
return _endofstorage - _start;
}
//[]运算符重载
T& operator[](size_t i)
{
assert(i < size());
return _start[i];
}
const T& operator[](size_t i) const
{
assert(i < size());
return _start[i];
}
//开辟特定空间
void reserve(size_t n)
{
T* temp = new T[n];
size_t sz = size();//提前计算好队列有多长，一会_start指针和_finish指针不在一个队列上了，就算不出来了
if (n > capacity())
{
if (_start)
{
/*memcpy(temp, _start, size() * sizeof(T));拷贝自定义类型时会出错*/
for (int i = 0; i < sz; i++)
{
temp[i] = _start[i];
}
delete[] _start;
_start = temp;
}
else
{
_start = temp;
}
}
_finish = _start + sz;
_endofstorage = _start + n;
}
//开辟特定空间并赋初值
void resize(size_t n, T val=T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
if(n>capacity())
{
reserve(n);
}
while (size() < n)
{
*_finish= val;
_finish++;
}
}
}
void push_back(const T& x)
{
if (_finish == _endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = x;
_finish++;
}
void pob_back()
{
assert(!empty());
_finish--;
}
//插入
void insert(iterator pos,const T& x)
{
if (_finish == _endofstorage)
{
size_t len = pos - _start;//保存一下pos的位置
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
iterator pos = _start + len;//重置pos，避免迭代器失效
}
iterator end = _finish-1;
while (end >= pos)
{
*(end + 1) = *end;
end--;
}
*pos = x;
_finish++;
}
//删除
iterator erase(iterator pos)
{
iterator temp = pos;
while (temp < _finish-1)
{
*temp = *(temp + 1);
temp++;
}
_finish--;
return pos;
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};3、使用memcpy拷贝问题
考虑一下，如果拷贝构造拷贝数据时使用memcpy会引起什么问题？
//拷贝构造
vector(const vector<T>& v)
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{
_start=new T[v.capacity()];
/*memcpy(_start,v._start,v.size()*sizeof(T)) 拷贝构造string等自定义类型时，会出问题*/
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}答：memcpy完成的是浅拷贝，当vector中存放的是内置类型时，是不会出问题的。但是如果vector中存放string类型，则会出现问题，因为是浅拷贝，会拷贝出一个相同的指针和原指针指向同一块空间，调用析构函数时会导致同一块空间被析构两次，发生报错。所以要采用for循环依次赋值，这样赋值时相当于调用string的深拷贝。
总结
本章主要简单介绍了vector容器的使用和简单模拟实现，如果感觉有帮助的话不妨点个赞支持一下博主哦~你们的支持就是我创作的最大动力，感谢大家的阅读。