---

前言

我们模拟vector是用迭代器（start，end，endofstorage）来控制增删查改操作的

一、 整体

1.命名空间:

namespace simulation {template<class T>//定义模板class vector {public:typedef T* iterator;typedef const T* const_iterator;//private:iterator _start;iterator _finish;iterator _endofstorage;};}

2构造函数：

1普通构造

vector():_start(nullptr),_finish(nullptr),_endofstorage(nullptr){}

2迭代器构造

template<class InputIterator>//【first，last）左闭右开区间vector(InputIterator first, InputIterator last) {while (first != last) {push_back(*first);first++;}}

3初始化字符构造

vector(size_t n, const T& val = T()) {
//const T& val = T()调用T的默认构造的缺省参数resize(n, val);}

4拷贝构造：

vector(const vector<T>& v) {_start = new T[v.capacity()];size_t sz = v.size();//提前记录下sizefor (size_t i = 0; i < sz; i++) {_start[i] = v._start[i];//实行深拷贝}_finish = _start + sz;_endofstorage = _start + v.capacity();}

3析构函数

~vector() {if (_start) {delete[] _start;_start = _finish = _endofstorage;}}

二、成员函数实现

1.大小

1当前大小(size())

//我本身是一个const对象，不可变，所以就需要调用一个const函数，
//但我要是一个非const对象，那么调用非const或者const函数是都都可以的
//这 成员函数加个const，这样const和非const对象都就可以调用了size_t size()const    {return _finish - _start;}

2总体容量(capacity())

size_t capacity() const   {return _endofstorage - _start;}

2.返回头尾迭代器

1begin（）

       iterator begin() {return _start;}const_iterator begin()const {return _start;}

2end（）

      iterator end() {return _finish;}const_iterator end()const {return _finish;}

3【】引用重载：

      T& operator[](size_t pos) {assert(pos < _finish);return _start[pos];}const T& operator[](size_t pos)const {assert(pos < _finish);return _start[pos];}

4.内存预留（reserve）

	void reserve(size_t n) {if (n > capacity()) {T* tmp = new T[n];size_t sz = size();//提前存下size，因为后面start会变动if (_start) {for (size_t i = 0; i < sz; i++) {tmp[i] = _start[i];}
//这里拷贝原来的数据不用memcpy是因为memcpy是浅拷贝我们vector要的是深拷贝
//所以用for循环调用赋值运算符重载，实现对象的深拷贝delete[] _start;}_start = tmp;_finish = _start + sz;_endofstorage = _start + n;}}

5.调整vector的有效长度（resize）

void resize(size_t n, const T& val = T()) {//将前n个数据初始化为val//从当前已有数据后面开始if (n < size()) {_finish = _start + n;}else {reserve(n);while (_finish != _start+n) {*_finish = val;_finish++;}}}

6.尾插（push_back）

void push_back(const T& x) {if (_finish == _endofstorage) {//判断是否需要扩容size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;reserve(newcapacity);}*_finish = x;_finish++;//或者insert(--end());}

7.在pos插入（insert）

iterator insert(iterator pos, const T& x) {assert(pos >= _start && pos <= _finish);if (_finish == _endofstorage) {size_t len = pos - _start;//算出pos的相对位置size_t newcapacity = capacity() == 0 ? 4 : capacity()  reserve(newcapacity);pos = _start + len;}iterator end = _finish - 1;while (end >= pos) {*(end + 1) = *end;--end;}*pos = x;++_finish;return pos;}

8.删除pos位置（erase）

iterator erase(iterator pos) {assert(pos >= _start && pos < _finish);iterator it = pos + 1;//将pos后面的数据朝前覆盖while (it != _finish) {*(it - 1) = *it;++it;}_finish--;return pos;}

9.赋值运算符重载

void swap(vector<T>& v) {std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_endofstorage, v._endofstorage);}vector& operator=(vector<T>  v) {swap(v);//创建一个临时对象，临时对象为v的拷贝//交换this与v的数据，出了作用域以后//this获得新的数据，临时对象v出作用域销毁return *this;}

深浅拷贝问题（reserve）：