前言

本节主要阅读了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;
 }
}