1. 基本成员函数

2. 默认成员函数

2.1 构造函数

2.2 析构函数

2.3 拷贝构造函数

2.4 赋值运算符重载函数

3. 容器访问相关函数

3.1 operator[ ]运算符重载

3.2 迭代器

3.3 范围for

4. vector空间增长问题

4.1 vector 容量和大小

4.2 vector扩容

4.3 重新定义大小

5. vector插入和删除

5.1 尾插

5.2 插入insert

5.3 尾删

5.4 erase删除

5.5 clear清空数据

6.总代码

6.1 vector.h

6.2 test.cpp

1. 基本成员函数

基本成员函数为三个指针，分别指向vector的开始，有效数字的位置，和容器的容量。

namespace cpp
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
	private:
		iterator _start;	  //指向容器的头
		iterator _finish;	  //指向有效数据的尾
		iterator _endofstoage;//指向容器的尾
	};
}

2. 默认成员函数

2.1 构造函数

（1）无参构造 vector<T> v

只需要把每个成员变量初始化为nullptr即可。
//无参构造函数
vector()
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstoage(nullptr)
{}
（2）有参构造 vector（v.begin()，v.end()）

有残构造是将区间[first，last]中的数据拷贝给本身。

vector的带参构造函数首先在初始化列表对基本成员变量初始化，在将迭代器区间在[first, last)的数据一个个尾插到容器当中即可：
//带参构造函数
template <class InputIterator>//函数模板
vector(InputIterator first, InputIterator last)
	: _start(nullptr)
	, _finish(nullptr)
	, _endofstoage(nullptr)
{
    //将迭代器区间在[first, last)的数据一个个尾插到容器当中
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}
（3）用n个val去初始化vector vector(n,val)

vector的构造函数还支持用n个val去初始化，只需要先调用reserve函数开辟n个大小的空间，再利用for循环把val的值依次push_back尾插进去即可。
//用n个val来构造vector
vector(size_t n, const T& val = T())
	: _start(nullptr)
	, _finish(nullptr)
	, _endofstoage(nullptr)
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}
这样写会出现一个问题：内存寻址错误。当我想实现下面的语句时：
cpp::vector<int> v(10, 4);
这里我调用的地方两个参数都是int，此时调用构造函数时匹配的是第二个传迭代器区间的构造函数，导致这样的原因在于编译器会优先寻找最匹配的那个函数。此构造函数的第一个参数是unsigned int类型，所以不会优先匹配此构造函数。因此我们需要再重载一个第一个参数为int类型的构造函数即可解决：
vector(int n, const T& val = T())
	: _start(nullptr)
	, _finish(nullptr)
	, _endofstoage(nullptr)
{		
    reserve(n);
	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}

2.2 析构函数

首先判断该容器_start是否为空，不为空就释放空间+置空即可。
//析构函数
~vector()
{
	if (_start)//避免释放空指针
	{
		delete[] _start;//释放容器所指向的空间
		_start = _finish = _endofstoage = nullptr;//置空
	}	
}

2.3 拷贝构造函数

vector(const vector &vec)

拷贝构造可以借助先前string的拷贝构造思路，利用现代方法解决，首先对基本成员变量进行初始化，接着建立一个tmp的模板将要拷贝的数据利用构造函数去传递过去，再将这个tmp模板与自己交换即可。
//拷贝构造函数
vector(const vector<T>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstoage(nullptr)
{
	vector<T> tmp(v.begin(), v.end());//调用构造函数
	swap(tmp);
}

2.4 赋值运算符重载函数

这里是传值传参，没有引用传参，直接利用vector调用构造函数返回的值与左值进行swap交换即可进行赋值。
//赋值运算符重载
vector<T>& operator=(vector<T> v)//调用构造
{
	this->swap(v);//交换这两个对象
	return *this;//返回
}

3. 容器访问相关函数

3.1 operator[ ]运算符重载

直接返回pos位置的数据即可进行下标+[ ]的方式进行访问。
//operator[]运算符重载
T& operator[](size_t pos)
{
    assert(pos < size());//检测pos的合法性
    return _start[pos];
}
为了方便const对象也可以调用[ ]运算符重载，因此还推出了一个const版本的[ ]运算符重载。
//const版本的[]运算符重载
const T& operator[](size_t pos) const
{
	assert(pos < size());//检测pos的合法性
	return _start[pos];	
}

3.2 迭代器

vector的begin直接返回容器的_start起始位置即可，vector的end返回容器的_finish的位置。
//begin
iterator begin()
{
	return _start;//返回容器起始位置
}
//end
iterator end()
{
	return _finish;//返回有效数据下一个的地址
}
const版本的迭代器如下：
//const版本迭代器
const_iterator begin() const
{
	return _start;
}
//end
const_iterator end() const
{
	return _finish;
}

3.3 范围for

范围for的底层是通过迭代器实现：

void test_vector()
{
	cpp::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
    //范围for
	for (auto e : v)
	{
		cout << e << " ";//1 2 3 4 5
	}
}

4. vector空间增长问题

4.1 vector 容量和大小

指针相减可以得到对应的个数，因此获取size只需_finish - _start。获取capacity只需_endofstoage - _start。

（1）size
size_t size() const //最好加上const，普通对象和const对象均可调用
{
	return _finish - _start; //指针相减就能得到size的个数
}
（2）capacity
size_t capacity() const
{
	return _endofstoage - _start;
}

4.2 vector扩容

reserve(int len);

reserve扩容和string的扩容非常相似。先开辟一块新的扩好容的空间，如果旧空间里头有数据，那么就利用for循环将容器中的数据一个一个拷贝到新空间，再释放旧空间，最后指向新空间。如果没有，直接指向新空间即可。
//reserve扩容
void reserve(size_t n)
{
	size_t sz = size();//提前算出size()的大小，方便后续更新_finish
	if (n > capacity())
	{
		T* tmp = new T[n];
		if (_start)//判断旧空间是否有数据
		{
			//不能用memcpy，因为memcpy是浅拷贝
			for (size_t i = 0; i < size(); i++)
			{
				tmp[i] = _start[i];//将容器当中的数据一个个拷贝到tmp当中
			}
			delete[] _start;//释放旧空间
		}
		_start = tmp;//指向新空间
	}
	//更新_finish和_endofstoage
	_finish = _start + sz;
	_endofstoage = _start + n;
}
注意：

在扩容结束后要记得更新_finish和_endofstoage，这里的_finsh要加上原先的size()长度，要先用变量sz保存下来，否则后续扩容后会更改指针的指向由原先的_start变为tmp，若直接+ size()函数的返回值会导致结果为随机值。
不能使用memcpy进行数据拷贝，因为memcpy是浅拷贝，它会将一段内存空间中内容原封不动的拷贝到另外一段内存空间中，导致后续delete时拷贝过的数据一并给delete了，具体下篇博文详谈。

4.3 重新定义大小

resize(int num); resize(int num.elem);//用elem填充

如果 n 小于当前容器的size()，则内容将减少到其前 n 个元素，删除超出（并销毁）的元素。
如果 n 大于当前容器 size()，则通过在末尾插入所需数量的元素以达到 n 的大小来扩展内容。若指定了 val，则新元素将初始化为 val 的副本，否则，它们将进行值初始化。
如果 n 也大于当前容器容量capacity()，则会自动重新分配分配的存储空间。
//resize
//void resize(size_t n, T val = T())
void resize(size_t n, const T& val = T()) //利用T()调用默认构造函数的值进行初始化，这样写说明C++的内置类型也有自己的构造函数
{
	//如果 n > capacity()容量，就需要扩容
	if (n > capacity())
	{
		reserve(n);
	}
	//如果 n > size()，就需要把有效数据_finish到_start + n之间的数据置为缺省值val
	if (n > size())
	{
		while (_finish < _start + n)
		{
			*_finish = val;
			_finish++;
		}
	}
	//如果 n < size()，更新有效数据到_start + n
	else
	{		
    	_finish = _start + n;
	}
}
补充：C++的内置类型也有自己的构造函数和析构函数，这样才能更好的支持模板。
void test()
{
	int i = 0;
	int j = int();
	int k = int(1);
	cout << i << endl;//0
	cout << j << endl;//0
	cout << k << endl;//1
}

4.4 swap交换

直接调用库函数的swap去进行成员变量的交换即可。
//交换函数
void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstoage, v._endofstoage);
}