【vector的模拟实现】

1、构造函数

//无参构造
vector()
			:_start(nullptr),
			_finish(nullptr),
			_endofstorage(nullptr)
		{}
//拷贝构造1
		vector(const vector<T>&v)
		{
			_start = new T[v.capacity()];
			_finish = _start + v.size();
			_endofstorage = _start + v.capacity();
			memcpy(_start, v._start, sizeof(T)*v.size());
		}
//拷贝构造2
		vector(const vector<T>&v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (const auto &i : v)
			{
				push_back(i);
			}
		}

2、析构函数

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

3、迭代器（原生指针）

	//原生指针
	typedef T* iterator;
	typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin()const//只能读不能写
		{
			return _start;
		}
		const_iterator end()const
		{
			return _finish;
		}

成员函数后面加const：
常常有一些成员函数不改变类的数据成员，也就是说，这些函数是"只读"函数，

4、reserve

void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T*tmp = new T[n];
				if (_start)
				{
					memcpy(tmp, _start, sizeof(T)*sz);
					delete[]_start;
				}
				_start = tmp;
				_finish = tmp + sz;//_finish指的是最后一个数据的下一个位置
				_endofstorage = tmp + n;
			}
		}

5、insert

void insert(iterator pos, const T&x)
		{
			assert(pos <= _finish);//注意原函数在_finish位置也可以插入数据
			if (_finish == _endofstorage)
			{
				size_t n = pos - _start;//保存pos到_start的距离
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + n;
				//一旦增容就要考虑迭代器失效问题,扩容后pos失效
			}
			iterator end = _finish - 1;
			while (end>=pos)//如果pos=_finish那么不进while循环
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++_finish;
		}

6、erase

iterator erase(iterator pos)//返回删除位置的下一个位置
		{
			assert(pos < _finish);
			iterator it = pos;
			while (it<_finish)
			{
				*it = *(it + 1);
				++it;
			}
			--_finish;
			return pos;//还是返回pos位置
		}

7、resize

void resize(size_t n, const T& val = T())//给的是T类型的缺省值
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else 
			{
				if (n > capacity())
				{
					reserve(n);
				}
				while (_finish < _start + n)
				{
					*(_finish) = val;
					_finish++;
				}
			}
		}

8、push_back

void push_back(const T& x)
		{
			/*if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			++_finish;*/
			insert(_finish, x);
		}

9、pop_back

void pop_back()
		{
			assert(_start < _finish);
			--_finish;
		}

10、赋值运算符重载

//=的重载1
vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				delete[]_start;
				_start = new T[v.capacity()];
				memcpy(_start, v._start, sizeof(T)*v.size());
				_finish = _start + v.size();
				_endofstorage = _start + v.capacity();
			}
			return *this;
		}*/
		//=的重载2(简便写法)
	vector<T>& operator=(vector<T>& v)
		{
			swap(v);
			return *this;
		}
		void swap(vector<T>&v)
		{
			//表示全局的swap
			::swap(_start, v._start);
			::swap(_finish, v._finish);
			::swap(_endofstorage, v._endofstorage);
		}

为什么要自己写swap函数：
具体代码：https://github.com/Wilingpz/sunny/tree/master/vector%E7%9A%84%E6%A8%A1%E6%8B%9F%E5%AE%9E%E7%8E%B0

tips：

当T是string的时候，牵扯到更深层次的深浅拷贝，将resever函数的memcpy函数改写为：

void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T*tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T)*sz);
					for(size_t i=0;i<sz;i++)
					{
					tmp[i]=_start[i];
			//这里采用赋值即可
					}
					delete[]_start;
				}
				_start = tmp;
				_finish = tmp + sz;//_finish指的是最后一个数据的下一个位置
				_endofstorage = tmp + n;
			}
		}