首先要先了解vector的使用，对于vector类成员和类函数使用还不清楚的可以自行去vector - C++ Reference查看。这里会首先提出几个使用的注意事项，接着会对vector的实现进行简单的剖析。
vector使用注意事项；
reserve的使用
在VS2019中，capacity 不会减容，只能扩容。但这个实现还是看编译器的，毕竟c++库里没有规定；
这种是比较好的；一般内存的释放都是一次性的；不存在一次一点一次一点；在哪创造的就在那里释放就很麻烦；所以不缩容很正确，也提高了效率；
迭代器失效
迭代器失效主要分为两种
- 存在扩容现象，类似与野指针的东西。
- 不存在扩容，由于数据已经挪动，位置已经改变，指针已不在指向原来的位置，我们就认为它失效了，不要访问。但是有的编译器会自动识别并拦截，有的遇到这种情况还能访问，出于安全性还是都不要访问的好；
这种情况在自己模拟实现vector时也会出现，毕竟这是确确实实的错误
这种就是VS的自动识别，会造成迭代器失效；但是自己实现vector时不会出现报错，但就尽量不使用就行了，（g++实现的vector 也不会有这个报错，但上一种情况就会出现）
还有就是 几乎所有容器 erase 之后都会迭代器失效；Insert是否失效看情况 看是否扩容
但是正确使用就行，erase 是有返回值的，用原来的p接收返回的删除后，原位置是数；如果是删除的最后一个则会返回最后一个值。
删除最后一个，在取pos值会造成迭代器失效
vector的模拟实现
成员函数
通过stl_vector的底层我们可以看到 vector的类成员是由三个组成的；
类似于这样
vector是从堆上分配内存的，大小与元素个数无关；（存的是地址）
一个共是四个成员函数，根据对齐原则我们可以判断，其大小应为16字节
但是通过打印可以知道
实际上编译器对vector的容量是32字节，那剩下了的字节编译器会实现什么内容，我们现在也无从而知；
毕竟STL是完全放开的东西，怎么实现vector类就看编译器了。
构造函数
要完成vector的基本构造函数，要写很多；
第一个就是vector<T> v1;类型的
第二个是要满足这种的
但是若使用 vector<int> v1(int , int)类型的 会先调用（vector(InputIterator first, InputIterator last)）
而不是（vector(size_t n, const T& val = T())），因为 int 转 size_t 类型比模板转换要更麻烦；所以要加一个 （vector(int n, const T& val = T())） 防止出错
//C++11 前置生成默认构造
vector() = default;vector(size_t n, const T& val = T()){reserve(n);for (size_t i = 0; i < n; ++i){push_back(val);}}//防止出错 (int ,int)类型构造优先走下面那个模板 而不是上面size_t 那个vector(int n, const T& val = T()){reserve(n);for (int i = 0; i < n; i++){push_back(val);}}template <class InputIterator>vector(InputIterator first, InputIterator last){reserve(last - first);auto i = first;while (i != last){push_back(*i);++i;}}插入删除
在VS编译器的insert 和 erase会自动识别迭代器失效，但是我们自己实现的就很难识别，所以在使用时要注意，insert 和 erase 之后 不要再次使用pos；除非自己已经了实现更新了pos的新位置；
使用memcpy拷贝问题
因为memecpy的拷贝是浅拷贝，若_start 中存储的是堆上的数据/自定义类型，还是会出现问题的；
因此，不要使用memcpy 。
void reserve(size_t n){if (capacity() < n){size_t count = size();iterator new = new T(n);//memcpy(new, _start);for (size_t i = 0; i < count; ++i){new.push_back(*(_start + i));}//防止内存泄漏delete[] _start;_start = new;_finish = _start + count;_end_of_storage = _start + n;}}代码参考
vector.h
#pragma once
#include<assert.h>
#include<list>
#include<string>namespace xryq {template<class T>class vector {public:typedef T* iterator;typedef const T* const_iterator;//vector(int n, const T& val = T())// :_start(new T(n, val))// ,_finish(_start + n)// ,_end_of_storage(_start + n)//{}vector(){}// C++11 前置生成默认构造/*vector = default;*/vector(size_t n, const T& val = T()){reserve(n);for (size_t i = 0; i < n; ++i){push_back(val);}}//防止出错 (int ,int)类型构造优先走下面那个模板 而不是上面size_t 那个vector(int n, const T& val = T()){reserve(n);for (int i = 0; i < n; i++){push_back(val);}}template <class InputIterator>vector(InputIterator first, InputIterator last){reserve(last - first);auto i = first;while (i != last){push_back(*i);++i;}}vector(const vector<T>& v){reserve(v.capacity());for (size_t i = 0; i < v.size(); ++i){this[i] = v[i];}}size_t capacity(){return _end_of_storage - _start;}size_t size(){return _finish - _start;}T& operator [](const size_t i) const{assert(i < capacity());return _start[i];}void clear(){_start = _finish;}//vector& operator =(const vector<T>& v)//{// if (this != &v)// {// clear();// reserve(v.capacity());// for (size_t i = 0; i < v.size(); i++)// {// push_back(v[i]);// }// }//}void swap(vector<T>& v){std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_end_of_storage, v._end_of_storage);}//现代写法 vector& operator =(vector<T> v){if (this != &v){swap(v);}return *this;}~vector(){if (_start){delete[] _start;_start = _finish = _end_of_storage = nullptr;}}void reserve(size_t n){if (capacity() < n){size_t count = size();T* tmp = new T[n];memcpy(tmp, _start,size() * 4);//for (size_t i = 0; i < count; ++i)//{// tmp[i] = _start[i];//}//防止内存泄漏delete[] _start;_start = tmp;_finish = _start + count;_end_of_storage = _start + n;}}void resize(size_t n, const T& x){if (n > size()){if (n > capacity()){reserve(n);}for (size_t i = 0; i < n - size(); i++){push_back(x);}}}void push_back(const T& x){if (_finish == _end_of_storage){reserve(capacity() == 0 ? 4 : capacity() * 2);}*_finish = x;++_finish;}bool empty(){return _start == _finish;}void pop_back(){assert(!empty());--_finish;}iterator insert(iterator pos, const T& x){assert(pos <= _finish);assert(pos >= _start);size_t oldsize = pos - _start;if (_finish == _end_of_storage){reserve(capacity() == 0 ? 4 : capacity() * 2);pos = _start + oldsize;}for (size_t i = size() - oldsize; i > 0; --i){pos[i] = pos[i - 1];}pos[0] = x;++_finish;return pos;}iterator erase(iterator pos){assert(pos < _finish);assert(pos >= _start);iterator i = pos + 1;while (i != _finish){*(i - 1) = *(i);++i;}--_finish;return pos;}iterator begin(){return _start;}iterator end(){return _finish;}const_iterator begin() const{return _start;}const_iterator end() const{return _finish;}private:iterator _start = nullptr;iterator _finish = nullptr;iterator _end_of_storage = nullptr;};void test_vector(){std::list<int> l1;l1.push_back(1);l1.push_back(1);l1.push_back(1);l1.push_back(1);l1.push_back(1);//vector<std::list<int>> v1(++l1.begin(), l1.end()--); }void test_vector1(){vector<std::string> v;v.push_back("1111111111111111111111111111111111111111");v.push_back("2222222222222222222222222222222222222222");v.push_back("3333333333333333333333333333333333333333");v.push_back("4444444444444444444444444444444444444444");v.insert(v.begin() + 2, "9999999999999999999999999999999999999999");}
}
