STL(queue)

void main()
{
	deque<int> de;
	for(int i=1; i<512; ++i)
	{
		de.push_back(i);
	}
	de.push_back(512);
	de.push_back(513);
}

//queue.h

#ifndef _VECTOR_H
#define _VECTOR_H


#include"memory.h"


template<class _Ty,class _A = _my_allocator<_Ty> >
class vector
{
public:
	typename typedef _A::size_type       size_type;
	typename typedef _A::value_type      value_type;
	typename typedef _A::pointer         pointer;
	typename typedef _A::const_pointer   const_pointer;
	typename typedef _A::reference       reference;
	typename typedef _A::const_reference const_reference;
	typename typedef _A::pointer         iterator;
	typename typedef _A::const_pointer   const_iterator;
public:
	explicit vector(const _A& _A1 = _A()):allocator(_A1),_First(0),_Last(0),_End(0)
	{}
public:
	iterator begin()
	{return _First;}
	iterator end()
	{return _Last;}
public:
	void push_back(const _Ty& _X)
	{insert(end(),_X);}
	size_type size()const
	{return (_First == 0?0:_Last-_First);}
public:
	iterator insert(iterator _P,const _Ty& _X = _Ty())
	{
		size_type _O = _P - begin();
		insert(_P,1,_X);
		return _O+begin();
	}
	
	void insert(iterator _P,size_type _M,const _Ty& _X)
	{
		
		if(_End - _Last < _M)//容量不够
		{
			size_type _N = size() + (size()>_M?size():_M);//至少开辟为原来的2倍
			iterator _S = allocator.allocator(_N,(void*)0);//申请空间
			iterator _Q = _Ucopy(_First,_P,_S);//从_First到_P区间的拷入到_S的位置（初始数据）
			_Ufill(_Q,_M,_X);//将_M个_X填充到_Q位置
			_Ucopy(_P,_Last,_Q+_M);//从P到Last区间内数据拷入到Q+M的位置上
			_Destory(_First,_Last);//摧毁原有的空间，调用析构函数（释放该对象所指的空间）
			allocator.deallocator(_First,_End-_First);//delete该对象，释放空间
			_Last = _S+size()+_M;
			_End = _S+_N;
			_First = _S;//???????????????????????????????????
		}
		
		else if(_Last - _P < _M)//容量够，空间不足
		{
			_Ucopy(_P,_Last,_P+_M);
			_Ufill(_Last,_M-(_Last-_P),_X);//先将Last所指空间数据填充进去，（因为Last所指的是最后一个元素的下一个）
			fill(_P,_Last,_X);//再填充P到Last区域间的数据
			_Last += _M;
		}
		else if(0<_M)
		{
			///
			_Ucopy(_Last - _M, _Last, _Last);
			copy_backward(_P, _Last - _M, _Last);
			fill(_P, _Last, _X);
			_Last += _M;
		}
	}
protected:
	void _Destory(iterator _F,iterator _L)
	{
		for(;_F!=_L;++_F)
			allocator.destory(_F);
	}
	iterator _Ucopy(const_iterator _F,const_iterator _L,iterator _P)//未初始化拷贝，在P所指位置拷贝一个从F到L的区间
	{
		for(;_F!=_L;++_F,++_P)
			allocator.construct(_P,*_F);
		return _P;
	}
	void _Ufill(iterator _F,size_type _N,const _Ty& _X)//在F所指位置填充N个X
	{
		for(;_N>0;--_N,++_F)
			allocator.construct(_F,_X);
	}
	void _Xran()const//异常函数，抛出异常
	{
		_THROW(out_of_range,"invalid vector<T> subscript!");//发生越界
	}
private:
	_A allocator;
	iterator _First;
	iterator _Last;
	iterator _End;
};


#endif

双端队列和向量一样支持在常数时间内存取任意元素，模板类deque是除了vector之外唯一一个支持随机存取迭代器的容器。它有一个很重要的方面做得比vector好———可以在被控序列的开始处以常数时间来插入或删除元素，当然也可以在末端进行插入。双端队列可以像列表一样很好的用来实现先进先出队列或后进后出的栈，当频繁地在任意位置插入新元素时，它就没有列表那么好了，双队列所需的时间为线性的，而列表只需要常数时间，然而，如果需要对被控序列中的元素进行随机存取，那么双队列就更胜一筹了。