文章目录
前言
本节主要阅读了vector的源码以及常用的接口模拟实现
一、vector的介绍和使用
1.vector的介绍
vector是表示可变大小数组的序列容器。
- 就像数组，vector也采用连续空间来存储元素，即可以使用下标对vector元素访问，但是它的大小是可以动态改变的，并且它的大小会被容器自动处理
- 本质上，vector使用动态分配数组来存储它的元素，当新元素插入，就需要重新分配大小增加存储空间。它的做法是，动态开辟一个新的数组，然后将元素移动进来。时间代价较高。事实上，每当一个新的元素加入到容器，并不会每次都重新分配空间。
- vector会分配一些额外空间适应可能的增长，因为存储空间比实际需要的存储空间大，不同的库采用不同的方法。但是本质上都是，重新分配增加新的元素个数的大小，在末尾插入元素。所以vector占用了更多的存储空间，为了管理存储空间，以有效的方式动态增长。
- 与其他动态序列容器相比（deque,list and forward list),vector访问元素更加高效，在末尾添加和删除元素高效，但是不在末尾的删除和插入操作效率更低。
2.vector的使用
在使用的时候，要对照文档来看，链接：https://cplusplus.com/reference/vector/vector/。
下面介绍一些常用的接口
2.1vector的定义
首先看一下源码，读源码中最重要的部分就是类的成员变量：
这里就看到了它的成员变量，但是是iterator类型，再找到
实际上iterator就是一个T*类型的指针。接下来看它的成员函数：
void push_back(const T& x) {
if (finish != end_of_storage) {
construct(finish, x);
++finish;
}
else
insert_aux(end(), x);
}这里push_back插入一个元素x，如果finish不等于end pf storage，就调用construct，finish++,否则，insert_aux，这里可以猜测到start指向数组的第一个位置，finish指向最后一个位置，end of storage是数组容量，再往后看它的成员函数reserve分析,start指向tmp,finish = tmp+old_size,end of storage = start+n，就明白了
start指向数组的起始位置
finish指向最后一个数据的下一个位置
end_of_storage表示这个容器的大小，指向这个容器最后一个位置的下一个位置。
| 构造函数声明 | 接口说明 |
| vector() | 无参构造 |
| vector(size_type n,const value_type&val= value_type()) | 构造并初始化n个val |
| vector(const vector&x) | 拷贝构造 |
| vector(InputIterator first,InputIterator last) | 使用迭代器进行初始化构造 |
2.2vector iterator的使用
| iterator的使用 | 接口说明 |
| begin+end | 获取第一个数据位置的iterator/const_iterator，获取最后一个数据的下一个位置的iterator/const_iterator |
| rbegin+rend |
获取最后一个数据位置的
reverse_iterator
，获取第一个数据前一个位置的reverse_iterator
|
看一下源码：
2.3vector空间增长问题
源码是这样写的：
size_type size() const { return size_type(end() - begin()); }
size_type max_size() const { return size_type(-1) / sizeof(T); }
size_type capacity() const { return size_type(end_of_storage - begin()); }
bool empty() const { return begin() == end(); }再去看它的end和begin定义，就是指向finish和start
iterator begin() { return start; }
const_iterator begin() const { return start; }
iterator end() { return finish; }
const_iterator end() const { return finish; }
reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());}
| 容量空间 | 接口说明 |
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
| resize | 改变vector的size |
| reverse | 改变vector的capacity |
1.resize
2.reserve
它提前开辟n个空间，如果比原来空间小，先保留原来空间的大小，然后开辟一段临时空间，再将原来空间的start,finish,end of storage放进去
2.4vector增删查改
源码如下：
void push_back(const T& x) {
if (finish != end_of_storage) {
construct(finish, x);
++finish;
}
else
insert_aux(end(), x);
}
void swap(vector<T, Alloc>& x) {
__STD::swap(start, x.start);
__STD::swap(finish, x.finish);
__STD::swap(end_of_storage, x.end_of_storage);
}
iterator insert(iterator position, const T& x) {
size_type n = position - begin();
if (finish != end_of_storage && position == end()) {
construct(finish, x);
++finish;
}
else
insert_aux(position, x);
return begin() + n;
}
template <class InputIterator>
void insert(iterator position, InputIterator first, InputIterator last) {
range_insert(position, first, last, iterator_category(first));
}
#else /* __STL_MEMBER_TEMPLATES */
void insert(iterator position,
const_iterator first, const_iterator last);
#endif /* __STL_MEMBER_TEMPLATES */
void insert (iterator pos, size_type n, const T& x);
void insert (iterator pos, int n, const T& x) {
insert(pos, (size_type) n, x);
}
void insert (iterator pos, long n, const T& x) {
insert(pos, (size_type) n, x);
}
void pop_back() {
--finish;
destroy(finish);
}
iterator erase(iterator position) {
if (position + 1 != end())
copy(position + 1, finish, position);
--finish;
destroy(finish);
return position;
}
iterator erase(iterator first, iterator last) {
iterator i = copy(last, finish, first);
destroy(i, finish);
finish = finish - (last - first);
return first;
}| vector增删查改 | 接口说明 |
| push_back | 尾插 |
| pop_back | 尾删 |
| find | 查找（这是算法模块实现，不是vector成员接口） |
| insert | 在position之前插入val |
| erase | 删除pos位置的数据 |
| swap | 交换两个vector的数据空间 |
| operator[] | 使用下标访问 |
2.5vector迭代器失效问题
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者对指针进行封装。比如：vector的迭代器就是原生指针T*。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃。
会引起迭代器失效的操作有：
- 会引起其底层空间改变的操作，都有可能是迭代器失效。比如：resize,reverse,insert,assign,push_back等。
#include <iostream>
using namespace std;
#include <vector>
int main()
{
vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
// v.resize(100, 8);
// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
// v.reserve(100);
// 插入元素期间，可能会引起扩容，而导致原空间被释放
// v.insert(v.begin(), 0);
// v.push_back(8);
// 给vector重新赋值，可能会引起底层容量改变
v.assign(100, 8);
/*
出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
*/
while(it != v.end())
{
cout<< *it << " " ;
++it;
}
cout<<endl;
return 0;
}
指定位置元素的删除操作-erase
#include <iostream>
using namespace std;
#include <vector>
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;
}erase删除pos位置元素后，pos位置之后的元素会往前挪动，没有导致底层空间的改变，理论上讲迭代器不会失效。但是，如果pos刚好指向最后一个元素，删除之后pos正好是end的位置，而end是最后一个位置的下一个，那么pos就是非法访问。因此，删除vector中任意位置上的元素的时候，vs认为该位置迭代器失效。
Linux下，g++编译器对迭代器的检查不是十分严格，处理也没有vs极端
与vector类似，string在插入和扩容，erase之后，迭代器也会失效
#include<string>
void TestString()
{
string s("hello");
auto it = s.begin();
// 放开之后代码会崩溃，因为resize到20会string会进行扩容
// 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
// 后序打印时，再访问it指向的空间程序就会崩溃
//s.resize(20, '!');
while (it != s.end())
{
cout << *it;
++it;
}
cout << endl;
it = s.begin();
while (it != s.end())
{
it = s.erase(it);
// 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
// it位置的迭代器就失效了
// s.erase(it);
++it;
}
}二、模拟实现一些vector常用接口
源码及注释已经上传gitee,链接：https://gitee.com/a_young/vector