vector容器、迭代器和空间配置器三个类方法的实现

C++的STL库有一个容器叫vector，这个容器底层的数据结构是一个内存可以自动增长的数组，每次当数组存储满了以后，内存可以自动增加两倍，请完成vector容器、迭代器和空间配置器三个类方法的实现。

#include<iostream>
using namespace std;
//容器默认的空间配置器的实现
template<typename T>
class myallocator
{
public:
	T* allocate(size_t size) //开辟内存
	{
		return (T*)malloc(size);
	}
	void deallocate(void *ptr) //释放内存
	{
		free(ptr);
	}
	void construct(T *ptr, const T &val)//构造对象
	{
		new(ptr)T(val);
	}
	void destroy(T *ptr) //析构对象
	{
		ptr->~T();
	}
};
//容器的类模板
template<typename E, typename allocator = myallocator<E>>
class Vector
{
public:
	//迭代器类型前置声明
	class iterator;
	//默认构造函数
	Vector(int size = 5)
	{
		_first = _allocator.allocate(size*sizeof(E));
		_end = _first + size;
		_last = _first;
	}
	//析构函数
	~Vector()
	{
		int size = _last - _first;
		for (int i = 0; i < size; ++i)
		{
			_allocator.destroy(_first + i);
		}
		_allocator.deallocate(_first);
		_first = _last = _end = NULL;
	}
	//拷贝构造函数
	Vector(const Vector<E, allocator> &src)
	{
		int length = src._end - src._first;
		_first = _allocator.allocate(length*sizeof(E));
		int size = src._last - src._first;
		for (int i = 0; i < size; ++i)
		{
			_allocator.construct(_first + i, src._first[i]);
		}
		_end = _first + size;
		_last = _first + length;
	}
	//赋值运算符的重载函数
	Vector<E, allocator>& operator=(const Vector<E, allocator> &src)
	{
		if (this == &src)
		{
			return*this;
		}
		int size = _last - _first;
		for (int i = 0; i < size; ++i)
		{
			_allocator.destroy(_first + i);
		}
		_allocator.deallocate(_first);
		_first = _last = _end = NULL;
		int length = src._end - src._first;
		_first = _allocator.allocate(length*sizeof(E));
		int size = src._last - src._first;
		for (int i = 0; i < size; ++i)
		{
			_allocator.construct(_first + i, src._first[i]);
		}
		_end = _first + size;
		_last = _first + length;
	}
	//向容器的末尾添加新元素value，若增长内存，调用resize函数
	void push_back(const E &value)
	{
		if (full())
		{
			resize();
		}
		_allocator.construct(_last, value);
		_last++;
	}
	//删除容器末尾的元素
	void pop_back()
	{
		if (empty())
		{
			return;
		}
		_last--;
		_allocator.destroy(_last);
	}
	//向指定位置插入新元素value，若增长内存，调用resize函数
	iterator insert(iterator it, const E &value)
	{
		if (it.mptr<_first || it.mptr>_last)
		{
			return _last;
		}

		if (_last == _end)
		{
			int offset = it.mptr - _first;
			resize();
			it.mptr = _first + offset;
		}

		E*p = _last;
		for (; p > it.mptr; --p)
		{
			_allocator.construct(p, *(p - 1));
			_allocator.destroy(p - 1);
		}
		_allocator.construct(p, value);
		_last++;
		return p;
	}
	//删除指定位置的元素
	iterator erase(iterator it)
	{
		if (it.mptr<_first || it.mptr >= _last)
		{
			return _last;
		}

		E*p = it.mptr;
		for (; p < _last - 1; ++p)
		{
			_allocator.destroy(p);
			_allocator.construct(p, *(p + 1));
		}
		_allocator.destroy(p);
		--_last;
		return it.mptr;
	}
	//判断容器是否空
	bool empty()const{ return _first == _last; }
	//判断容器是否满
	bool full()const{ return _last == _end; }

	//容器的迭代器实现
	class iterator
	{
	public:
		iterator(E*ptr = NULL) :mptr(ptr){}
		bool operator!=(const iterator&it)
		{
			return mptr != it.mptr;
		}
		void operator++()
		{
			mptr++;
		}
		E&operator*()
		{
			return*mptr;
		}
		E*mptr;
	};
	iterator begin(){ return iterator(_first); }
	iterator end(){ return iterator(_last); }
private:
	//内存增长函数，按原有容量的两倍增长
	void resize()
	{
		int size = _last - _first;
		E*ptmp = _allocator.allocate((size)*sizeof(E)* 2);

		for (int i = 0; i < size; ++i)
		{
			_allocator.construct(ptmp + i, _first[i]);
		}
		for (int i = 0; i < size; ++i)
		{
			_allocator.destroy(_first + i);
		}
		_allocator.deallocate(_first);
		_first = ptmp;
		_end = _first + size * 2;
		_last = _first + size;
	}
	E *_first;   //指向数组的起始位置
	E *_end;	   //指向数组的末尾的后继位置
	E *_last;     //指向数组最后一个有效数据的后继位置
	allocator _allocator; // vector容器的空间配置器
};
int main()
{
	Vector<int>Vec;
	Vec.push_back(20);
	Vec.push_back(21);
	Vec.push_back(22);
	Vec.push_back(23);
	Vec.push_back(24);
	Vec.push_back(25);
	Vec.push_back(26);
	Vec.pop_back();

	Vec.erase(Vec.begin());
	Vec.insert(Vec.begin(),66);
	Vector<int>::iterator it = Vec.begin();
	for (; it != Vec.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：