目录

1.构造函数

（1）无参构造

（2）带参构造函数

（3）用迭代器构造初始化函数

（4）拷贝构造函数 

 2.operator=

3.operator[]

4.size()

5.capacity()

6.push_back

 7.reserve

 8.迭代器（vector的原生指针）

9.resize

10.pop_back

11.insert

12.erase

13.memcpy替换为深拷贝

---

 大致框架

namespace zbw
{
	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

1.构造函数

（1）无参构造

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

（2）构造n个val

	vector(size_t n,const T& val = T())//const延长匿名对象的生命周期
		:_start(nullptr)
		, _finish(nullptr)
		, _end_of_storage(nullptr)
	{
		reverse(n);
		for (int i = 0; i < n; i++)
		{
			push_back(val);
		}
	}

匿名对象生命周期只有这一行，调用完匿名函数后会调用析构函数将其析构

但引用会延长匿名对象的生命周期到引用对象域结束，由于匿名对象具有常性，所以需要用const修饰，此时调用完匿名对象，并不会调用析构函数释放

（3）用迭代器构造初始化函数

	tmplete <class InputIterator>
	vector(InputIterator first,InputIterator last)
		:_start(nullptr)
		, _finish(nullptr)
		, _end_of_storage(nullptr)
	{
		while (first != last)
		{
			push_back(*first);
			first++;
		}
	}

使用迭代器模板，就可以传任意类型的迭代器，否则只能使用vector的迭代器

起名为InputIterator,是因为函数模板的模板参数要传迭代器区间时，是存在命名规范的

InputIterator这种迭代器所指的对象为“只读”，不允许外界更改

（4）拷贝构造函数 

传统写法

	vector(const vector<T>& v)//v2(v1)
	{
		_start = new T[v.capacity()];
		_finish = _start + v._size();
		_end_of_storage = _start + v._capacity;

		memcpy(_start, v._start, v.size() * sizeof(T));
	}

开一块和v1一样大的空间，再把v1的数据拷贝到新空间里去

现代写法 

	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(const vector<T>& v)//v2(v1)
	{
		vector<T> tmp(v.begin(), v.end());
		swap(tmp);
	}

 利用迭代器初始化的构造函数，用v1创造一个临时变量tmp，再将v2与tmp交换，tmp出了作用域就调用析构函数销毁

最终版本：（防止浅拷贝）

vector(const vector<T>& v)//拷贝构造
{
	reserve(v.capacity());
	for (size_t i = 0; i < v.size(); i++)
	{
		_start[i] = v._start[i];//使用默认的赋值运算符会发生浅拷贝
	}
	_finish = _start + v.size();
}

 2.operator=

现代写法

	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<T>& operator=(const vector<T> v)//v3 = v1
	{
		swap(v);
		return *this;
	}

利用传值传参拷贝构造v（此时v就是v1），再将v3与v1交换，v是临时对象除了作用域会调用析构函数销毁

3.operator[]

	T& operator[](size_t i)
	{
		assert(i < size())