//---------------------------15/3/13----------------------------
self&operator++()
{
++cur;
if(cur==last)
{
set_node(node+1);
cur=first;
}
return *this;
}
self operator++(int) //这里不能返回引用，因为 tmp是临时变量，作用域结束tmp就消失了
{
self tmp=*this;
++*this;
return tmp;
}
self&operator--()
{
if(cur=first)
{
set_node(node-1);
cur=last;
}
--cur;
return *this;
}
selfoperator--(int)
{
self tmp=*this;
--*this;
return temp;
}
/*
1.看能否在不改变node的情况下进行指针位置的移动
2.调整node
offset==(n+x) -->> 最后的位置==first + (n + x)
x代表cur 距离first的距离,也就是cur当前的下标
(offset>0): offset/diffenrence_type(buffer_size())
-->> y==(n + x)/(sz) -->>移动的node节点个数为y
(offset<0) -difference_type((-offset -1) / buffer_size()) - 1
-->> y==-(-n - x -1)/(sz) -1 -->> y==(n + x +1)/(sz) -1
不同于(offset<0)的情况,因为当前处于first位置，移动的距离在
-1到－(sz)是都应该移动一个node节点所以才取上式子;
3.调整cur
(offset>0) :offset==(n + x)
node_offset*difference_type(buffer_size())==（n + x -r)
(r代表余数)
-->>z(位移量)==r
(offset<0) :offset==(n + x)
node_offset*difference_type(buffer_size())==(n + x +r-sz)
-->>z(位移量)==-sz + r
cur =z
*/
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;
}
selfoperator+(difference_type n) const
{
self tmp=*this;
return tmp+=n;
}
self &operator -=(difference_type n){return *this +=-n;}
selfoperator-(difference_type n) const
{
self tmp =*this;
return tmp-=n;
}
referenceoperator[](difference_type)const{return *(*this +n);}
bool operator==(const self& x)const{return cur==x.cur;}
bool operator!=(const self& x)const {return !(*this==x);}
bool operator<(const self& x)const
{
return (node==x.node)?(cur < x.cur) :(node < x.node);
}
template<class T,class Alloc = alloc,size_t BufSiz=0>
class deque
{
public:
typedef T value_type;
typedef value_type* pointer;
typedef size_t size_type;
typedef __deque_iterator<T,T&,T*,BufSiz> iteratoer;
protected:
typedef pointer* map_pointer;
iteratoer start;
iteratoer finish;
map_pointer map;
size_type map_size;
public:
iteratoer begin(){return start;}
iteratoer end() {return finish;}
referenceoperator[](size_type n)
{
return start[difference_type(n)];
}
reference front(){return *start;}
reference back()
{
iteratoer tmp=finish;
--tmp;
return *tmp;
//上面三行不改为 return *(finish-1)是因为operator -(difference_type n)
// 的操作比--复杂很多
}
size_type size()const {return finish - start;;}//两个;是手误？？
}