引言：
什么是vector？
vector是一个封装了动态数组的顺序容器，与其他类型容器一样，能够存放各种类型的对象，可以简单的认为，vector是一个能够存放任意类型的动态数组，但与顺序表不同的是vector的成员遍历是三个迭代器，也可以说是三个指针。
template<class T>
class vector
{
public:typedef T* iterator;//...private:iterator _start=nullptr;iterator _finish=nullptr;iterator _end_of_storage=nullptr;};
其中_start指向起始位置，_finish指向有效数据末尾的后一个位置， _end_of_storag指向容量大小末尾的后一个位置。
一、成员函数
1.1构造函数
1.1.1无参构造
只需将三个成员变量置为空指针即可
//无参构造
vector():_start(nullptr), _finish(nullptr), _end_of_storage(nullptr)
{}1.1.2使用迭代器区间构造
当我们想要以某个对象的区间来进行初始化时，需要用到模板
//迭代器区间构造
//类模板的成员函数，可以继续是函数模板
template<class Inputiterator>
vector(Inputiterator first, Inputiterator last)
{while (first != last){push_back(*first);++first;}
}1.1.3构造并初始化n个val
vector也支持容器中含有n个值为val的数据，注意在尾插之前要先进行扩容
//n个val构造
vector(size_t n, const T& val=T())
{reserve(n);for (size_t i = 0; i < n; i++){push_back(val);}
}注：在设计带参构造函数时需要使用匿名对象作为缺省值（ const T& val=T() ），因为T类型不确定，在设置缺省值时只能使用匿名对象的方式。
这里其实还要将n重载为int类型
//n个val构造
vector(int n, const T& val=T())
{reserve(n);for (size_t i = 0; i < n; i++){push_back(val);}
}这是为了防止传两个int型参数时被编译器交给1.1.2中的模板 Inputiterato识别，会报错，因为其中的*first只能对指针和迭代器解引用，而不能对数据解引用。
1.2拷贝构造
开辟一个新空间，在进行一个个拷贝即可
//拷贝构造
vector(const vector<T>& v)
{ _start = new T[v.capacity()];//一个个进行深拷贝for (size_t i = 0; i < v.size(); ++i){_start[i] = v._start[i];}_finish = _start + v.size();_end_of_storage = _start + v.capacity();}
这里要注意的是：对于自定义类型，不能用memcpy进行拷贝，因为它进行的是浅拷贝，如果模板T是string,vector等自定义类型，则程序结束回收时就会引发内存错误。而对于内置类型则可以用memcpy。
这里还有一种写法更简洁：
//拷贝构造
vector(const vector<T>& v)
{//预留空间reserve(v.size());//深拷贝 遍历尾插for (auto& e : v){push_back(e);}
}1.3运算符赋值重载
传统写法：开辟一个新空间然后将容器中的数据一个个拷贝过去
//赋值重载
//传统写法
vector <T>& operator=(const vector<T>& v)
{if (this != &v){//将this清理干净clear();reserve(v.size());for (auto& e : v){push_back(e);}}return *this;
}现代写法：
注意：这里在传参时并没有引用传参，因为这样可以间接调用vector的拷贝构造函数，然后将拷贝构造出来的容器v与this进行交换，即可完成赋值操作，而容器v会在函数调用结束时自动析构进行释放。
//赋值重载现代写法
//v1=v3
//这里不能用&，这样v3就变成v1了，而我们的目的是让v1=v3
vector <T>& operator=( vector<T> v)//传值传参
{swap(v);return *this;
}void swap(vector<T>& v)
{std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_end_of_storage, v._end_of_storage);
}1.4析构函数
清理资源即可
~vector()
{delete[]_start;_start = _finish = _end_of_storage;
}二、元素访问
2.1迭代器
我们访问vector中的元素时，可以用迭代器的形式去遍历
typedef T* iterator;
typedef const T* const_iterator;非const
//迭代器
iterator begin()
{return _start;
}iterator end()
{return _finish;
}const
const_iterator begin() const
{return _start;
}const_iterator end() const
{return _finish;
}2.2operator[ ]
对于vector中的元素的访问最常用的是下标+[ ]
//访问第i位 数据
T& operator[](size_t i)
{assert(i < size());return _start[i];
}
三、容量
3.1size
size是有效元素的个数，只需_finish-_start即可
size_t size()const
{return _finish - _start;
}
3.2capacity
capacity是空间大小，只需_end_of_storage - _start即可
size_t capacity()const
{return _end_of_storage - _start;
}3.3reserve扩容
这里我们采用的逻辑是：若n>capacity,则扩容到n，若n<capacity则不变化
有一个注意的点是：先将size()记录下来， 方便后面操作 ，因为size()是finish-start，要防止异地扩容原数组释放之后找不到_start指针，进而找不到原数组的大小
//扩容
void reserve(size_t n)
{if (n > capacity()){//先将size()赋值给一个变量 方便后面操作 因为size()是finish-start//_start后面是要变得size_t old_size = size();T* tmp = new T[n];//写反了就完蛋memcpy(tmp, _start, size() * sizeof(T));delete[]_start;_start = tmp;_finish = tmp + old_size;_end_of_storage = tmp + n;}
}3.4resize
这里分成三个逻辑：
1.当n<size时，resize要删除字符到指定大小
2.当size<n<capacity，resize会补充有效字符（默认为0）到指定大小
3.当n>capacity，resize会补充有效字符（默认为0）到指定大小
void resize(size_t n, const T& x = T())
{if (n < size()){_finish = _start + n;}else{reserve(n);while (_finish < _start + n){*_finish = x;++_finish;}}}四、修改器
4.1尾插push_back
这里要注意会涉及到扩容的问题
//尾插
void push_back(const T&x)
{//如果满了if (_finish == _end_of_storage){reserve(capacity()==0 ? 4 : capacity() * 2);}*_finish = x;++_finish;}4.2尾删pop_back
要注意进行判空操作
bool empty()
{return _start == _finish;
}//尾删
void pop_back()
{assert(!empty());--_finish;
}
4.3insert
我们要从pos位置，先去挪动pos后面的数据，从后往前挪，避免数据覆盖，挪完之后再在pos位置插入数据即可，同时我们也需要插入数据之后的扩容问题
//在pos位置插入
iterator insert(iterator pos, const T& x)
{//扩容if (_finish == _end_of_storage){reserve(capacity() == 0 ? 4 : capacity() * 2);}iterator end = _finish - 1;while (end >= pos){//把pos之后的数据一个个往后挪*(end + 1) = *end;--end;}*pos = x;++_finish;return pos;
}注：这里存在迭代器失效的问题
1.若存在扩容，扩容完之后，当前对象的_start已经指向了新的空间，而pos还指向原来的已经释放了的空间，这时候pos就有点类似野指针的问题，造成pos迭代器失效。
这种情况的解决方法可以记录pos的相对位置，以便在新空间中还能找到正确的pos位置
2.不存在扩容，但是由于数据从后往前依次挪动而pos指向的位置不变，所以pos这个迭代器也已经失效，位置意义已经改变。
所以迭代器insert之后就不要直接访问，如果要访问就要更新这个失效的迭代器的值
//在pos位置插入
iterator insert(iterator pos, const T& x)
{//扩容if (_finish == _end_of_storage){//需要记录pos的相对位置，避免迭代器失效的问题size_t len = pos - _start;reserve(capacity() == 0 ? 4 : capacity() * 2);pos = _start + len;}iterator end = _finish - 1;while (end >= pos){//把pos之后的数据一个个往后挪*(end + 1) = *end;--end;}*pos = x;++_finish;return pos;
}
4.4erase
这里挪动数据需要一个个往前挪，防止覆盖
iterator erase(iterator pos)
{assert(pos<_finish && pos>_start);iterator it = pos + 1;//记录pos下一个元素的位置//从后往前挪while (it != v.end()){*(it - 1) = *it;++it;}--_finish;return pos;
}注：erase删除pos位置元素后，pos位置之后的元素会往前挪，没有导致底层空间的改变，理论上迭代器不会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上的元素时，vs就认为该位置迭代器失效了。
测试：
以上就是我对vector模拟实现的理解！
