deque C++实现

模仿源码，对deque进行了实现。deque是vector和list的折中。与其说deque是stl中的一个组件不如说是一种设计思想。代码如下，虽注释较少但简单易懂。

/*copyright(c):2014-2020.written by zx 2014.5  
*/

#include<iostream>
#include<algorithm>
#include<type_traits>
using namespace std;

/*buffer size set*/
inline size_t _deque_buf_size(size_t n,size_t sz){
	return n!=0 ? n:(sz<512? size_t(512/sz):size_t(1));
}

/*一些空间配置器里面的函数*/
struct __false_type{};
struct __true_type{};  
struct input_iterator_tag {};

template<class T,class Ref,class Ptr,size_t BufSiz>

class Deque_iterator{
public:
	typedef Deque_iterator<T,T&,T*,BufSiz> iterator;
	typedef Deque_iterator<T,const T&,const T*,BufSiz> const_iterator;
	static size_t buffer_size(){return _deque_buf_size(BufSiz,sizeof(T));}
	//5个基本的迭代器型别
	typedef random_access_iterator_tag iterator_category; 
    typedef T value_type;  
    typedef T* pointer;  
    typedef T& reference;  
    typedef size_t size_type;  
    typedef ptrdiff_t difference_type; 
	typedef T** map_pointer;

	typedef Deque_iterator self;
	T* cur; //访问缓冲区
	T* first ; //指向缓冲区头
	T* last; // 指向缓冲区尾
	map_pointer node; //map中控器
	Deque_iterator():first(0),cur(0),last(0),node(0){}
	Deque_iterator(T* x,map_pointer y):cur(x),first(*y),last(*y+buff_size()),node(y){}
	Deque_iterator(const Deque_iterator& x ):
	cur(x.cur),first(x.first),last(x.last),node(x.node){}	
	void set_node(map_pointer new_node){
		node = new_node;
		first = *new_node;
		last = first + difference_type(buffer_size());
	}
	reference operator*()const{return *cur;}
	pointer operator->()const{return &(operator*());}
	difference_type operator -(const self& x)const{ //量迭代器之间的距离
		return difference_type(buffer_size())*(node-x.node-1)+(cur-first)+(x.last-x.cur);
	}
	self& operator++(){
		++cur;
		if(cur == last){
			set_node(node+1); //切换至下一节点
			cur = first;
		}
		return *this;
	}
	self operator++(int){
		self tmp = *this;
		++*this;
		return tmp;
	}
	self& operator--(){
		if(cur==first){
			set_node(node -1);
			cur = last;
		}
		--cur;
		return *this;
	}
	self operator--(int){
		self tmp = *this;
		--*this;
		return tmp;
	}
	self& operator+=(difference_type n){
		difference_type offset = n + (cur - first);
		if(offset>=0&&offset<=difference_type(buffer_size()))
			cur += n;
		else {
			difference_type node_offset = offset>0? offset/difference_type(buffer_size()):
				-difference_type((-offset - 1) / buffer_size()) - 1; 
			set_node(node+node_offset);
			cur  =  first + (offset - node_offset * difference_type(buffer_size())); 
		}
		return *this;
	}
	self operator+(difference_type n){
		self tmp = *this;
		return tmp+= n ;
	}
	self& operator-=(difference_type n){return *this+= -n ;}
	self operator-(difference_type n)const{
		self tmp = *this;
		return tmp+= -n;
	}
	bool operator==(const self& x)const{return (cur == x.cur);}
	bool operator!=(const self& x)const{return (cur != x.cur);}
	bool operator<(const self& x)const{//同一个节点或者不同节点
		return node == x.node?(cur<x.cur):(node<x.node);
	}
	reference operator[](difference_type n) const { return *(*this + n); }
};

template<class T,size_t BufSize = 0>
class Deque{
public:
	typedef T value_type;
	typedef value_type* pointer;
	typedef value_type& reference;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
public:
	typedef Deque_iterator<T,T&,T*,BufSize> iterator;
protected:
	typedef pointer* map_pointer; // 中控器
	static size_type buffer_size(){
		return _deque_buf_size(BufSize,sizeof(value_type));
	}
	static size_type initial_map_size() { return 8; }  
protected:
	iterator start;
	iterator finish;
	map_pointer map;
	size_type map_size; // map容量
private:
	inline void destroy(iterator first1, iterator last1)  
	{  
		__destroy(first1, last1, pointer(0));  
	}
	inline void __destroy(iterator first, iterator last, T*)  
	{  
		//typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;  
		//__destroy_aux(first, last, __false_type);  
		__destroy_aux(first, last); 
	}  
	inline void  __destroy_aux(iterator first, iterator last)  
	{  
		for ( ; first < last; ++first)  
			destroy(&*first);  
	}  
	inline void destroy(pointer first,pointer last){
		for(;first<last;++first)
			destroy(first);
	}
	inline void destroy(T* pointer)  
	{  
		pointer->~T(