Ch4 序列式容器（上）
4.1 容器的概观与分类
4.2 vector
4.2.3 vector的迭代器
vector的迭代器是普通指针，属于Random Access Iterator。
template <class T, class Alloc=alloc> class vector { public: typedef T value_type; typedef value_type* iterator; ... }; //如： vector<int>::iterator ivite; // ivite的型别就是int*
4.2.4 vector的数据结构
为了降低空间配置时的速度成本，vector实际配置的大小可能比客户端需求量更大一些（大于等于，等于的时候说明满载了，再有新增元素，整个vector就需要重新malloc了）：
template <class T, class Alloc = alloc> class vector { ... protected: iterator start; //表示目前使用空间的头 iterator finish; //表示目前使用空间的尾 iterator end_of_storage; //表示目前可用（含备用）空间的尾 ... };运用以上三个迭代器，vector可提供以下操作：
template <class T, class Alloc = alloc> class vector { ... public: iterator begin() { return start; } iterator end() { return finish; } size_type size() const { return size_type(end() - begin()); } size_type capacity() const { return size_type(end_of_storage - begin()); } bool empty() const { return begin() == end(); } reference operator[] (size_type n) { return *(begin()+n); } reference front() { return *begin(); } reference back() { return *(end()-1); } ... };
4.2.5 vector的构造与内存管理：constructor，push_back
vector缺省使用alloc作为空间配置器，并据此另定义了一个data_allocator（为了方便以元素大小为配置单位）：
template <class T, class Alloc = alloc> class vector { protected: typedef simple_alloc<value_type,Alloc> data_allocator; ... }; //data_allocator::allocate(n) 表示配置n个元素空间
vector提供了许多constructors：
//构造函数，允许指定vector大小n和初值value vector( size_type n, const T& value) { fill_initialize(n, value); } //填充并予以初始化 void fill_initialize( size_type n,const T& value ) { start = allocate_and_fill(n, value); finish = start +n; end_of_storage = finish; } //配置而后填充 iterator allocate_and_fill(size_type n, const T& x) { iterator result = data_allocator::allocate(n); //配置n个元素空间 uninitialized_fill_n(result, n, x); return result; }
以下是使用push_back()将新元素插入于vector尾部时的源码：
void push_back(const T& x) { if( finish!= end_of_storage) { //还有备用空间 construct( finish, x); ++finish; }else{ insert_aux(end(), x); //没有备用空间，扩充空间 } template <class T, class Alloc> void vector<T ,Alloc>::insert_aux(iterator position, const T& x) { if( finish != end_of_storage) { //在备用空间起始处构造一个元素，并以vector最后一个元素值为其初值 construct( finish, *(finish -1)); ++finish; T x_copy=x; copy_backward( position, finish -2 , finish-1); *position =x_copy; }else{ //如果原大小为0，则配置1 //如果原大小不为0，则配置原大小的两倍 //前半段用来放置原数据，后半段用来放置新数据 const size_type old_size =size(); const size_type len= old_size !=0 ? 2*old_size :1; iterator new_start =data_allocator::allocate(len); iterator new_finish =new_start; try{ //将原vector的内容拷贝到新vector new_finish = uninitialized_copy(start, position, new_start); //将新元素设定初值x construct(new_finish, x); ++new_finish; //将新安插点的原内容也拷贝过来 new_finish = uninitialized_copy(position, finish,new_finish); }catch(...) { destroy(new_start, new_finish); data_allocator::deallocate(new_start,len); throw; } //析构并释放原vector destroy(begin(),end()); deallocate(); //调整迭代器，指向新vector start=new_start; finish=new_finish; end_of_storage=new_start+len; } }注意：所谓动态增加大小，并不是在原空间之后续接新空间（因为无法保证原空间之后尚有可供配置的空间），而是以原大小的两倍另外配置一块较大空间，然后将原内容拷贝过来，然后才开始在原内容之后构造新元素，并释放原空间。因此，对vector的任何操作，一旦引起空间重新配置，指向原vector的所有迭代器就都失效了。
4.2.6 vector的元素操作：pop_back，erase，clear，insert
pop_back：
//把尾端元素拿掉，并调整大小 void pop_back() { --finish; destroy(finish); }
erase：
iterator erase(iterator first, iterator last) { iterator i=copy(last, finish, first); destroy(i,finish); finish=finish-(last-first); return first; } iterator erase(iterator position){ if(position+1!=end()){ copy(position+1, finish, position); } --finish; destroy(finish); return position; }
clear：
void clear() { erase(begin(), end()); }
insert：
template <class T, class Alloc> void vector<T,Alloc>::insert(iterator position, size_type n, const T& x) { if(n!=0){ if(size_type(end_of_storage - finish) >=n ) { //备用空间大于等于“新增元素个数” T x_copy=x; //计算位于插入点后面的现有元素个数 const size_type elems_after=finish-position; iterator old_finish=finish; if(elems_after>n){ //“位于插入点后面的现有元素个数”大于“新增元素个数” uninitialized_copy( finish-n, finish, finish); finish+=n; copy_backward(position, old_finish_n. old_finish); fill(position, position+n, x_copy); //从插入点开始填入新值 }else{ uninitialized_fill_n(finish, n-elems_after, x_copy); finish+=n-elems_after; uninitialized_copy(position, old_finish, finish); finish+=elems_after; fill(position, old_finish,x_copy); } }else{ //需要配置额外的内存 const size_type old_size=size(); const size_type len=old_size+max(old_size,n); //配置新的vector空间 iterator new_start =data_allocator::allocate(len); iterator new_finish =new_start; _STL_TRY{ //首先将旧vector的位于插入点之前的元素复制到新空间 new_finish=uninitialized_copy(start, position, new_start); //再将新增元素（初值皆为x）填入新空间 new_finish=uninitialized_fill_n(new_finish, n, x); //再将旧vector的位于插入点之后的元素复制到新空间 new_finish=uninitialized_copy(position, finish, new_finish); } #ifdef __STL_USE_EXCEPTIONS catch(...){ destroy(new_start, new_finish); data_allocator::deallocate(new_start,len); throw; } #endif //清除并释放旧的vector destroy(start,finish); deallocate(); start=new_start; finish=new_finish; end_of_storage=new_start+len; } } }
4.3 list
4.3.1 list概述
相比vector，list每次插入或删除一个元素，就配置或释放一个元素空间，因此list不会浪费空间，且对于任何位置的元素插入或元素移除，list都是常数时间。
4.3.2 list的节点
template <class T> struct __list_node { typedef void* void_pointer; void_pointer prev; //即 __list_node<T>* void_pointer next; T data; }
4.3.3 list的迭代器
STL list是双向链表，故其迭代器必须具备前移、后移的能力，所以list的迭代器是Bidirectional Iterators：
template <class T, class Ref, class Ptr> struct __list_iterator { typedef __list_iterator<T,T&,T*> iterator; typedef __list_iterator<T,Ref,Ptr> self; typedef bidirectional_iterator_tag iterator_category; typedef T value_type; typedef Ptr pointer; typedef Ref reference; typedef __list_node<T>* link_type; typedef size_t size_type; typedef ptrdiff_t difference_type; link_type node; //指向list节点的普通指针 //constructor __list_iterator(link_type x): node(x) { } __list_iterator() { } __list_iterator(const iterator& x): node(x.node) { } bool operator==(const self& x) const { return node == x.node; } bool operator!=(const self& x) const { return node != x.node; } //对迭代器取值，取节点的数据值 reference operator*() const { return (*node).data; } //迭代器的成员存取运算子的标准做法 pointer operator->() const { return &(operator*()); } //对迭代器累加1，即前进一个节点 self& operator++(){ node=(link_type)((*node).next); return *this; } self operator++(int) { self tmp=*this; ++*this; return tmp; } //对迭代器递减1，即后退一个节点 self& operator--(){ node=(link_type)((*node).prev); return *this; } self operator--(int) { self tmp=*this; --*this; return tmp; }}
4.3.4 list的数据结构
SGI list还是一个环状双向链表，所以它只需要一个指针，便可以完整表现整个链表：
template <class T,class Alloc = alloc> class list { protected: typedef __list_node<T> list_node; public: typedef list_node* link_type; protected: link_type node; ... }如果让指针node指向刻意置于尾端的一个空白节点，node便能符合STL对于“前闭后开”区间的要求，成为last迭代器。
4.3.5 list的构造与内存管理：constructor,push_back,insert
list缺省使用alloc作为空间配置器，并据此另定义了一个list_node_allocator（为了方便以节点大小为配置单位）：
template <class T, class Alloc = alloc> class list { protected: typedef __list_node<T> list_node; //空间配置器，每次配置一个节点大小 typedef simple_alloc<list_node,Alloc> list_node_allocator; ... //list_node_allocator(n) 表示配置n个节点空间 ... protected: //配置一个节点并传回 link_type get_node() { return list_node_allocator::allocate(); } //释放一个节点 void put_node(link_type p) { list_node_allocator::deallocate(p); } //产生（配置并构造）一个节点，带有元素值 link_type create_node( const T& x){ link_type p=get_node(); construct(&p ->data, x); return p; } //销毁（析构并释放）一个节点 void destroy_node(link_type p){ destroy(&p->data); put_node(p); } }
list的default constructor：
public: list() { empty_initialize(); } //产生一个空链表 protected: void empty_initialize() { node=get_node(); //配置一个节点空间，令node指向它 node->next=node; //令node头尾都指向i自己，不设元素值 node->prev=node; }
使用push_back()将新元素插入于list尾端时，函数内部调用insert：
void push_back(const T& x) { insert(end(), x); }
insert()，在迭代器position所指位置插入一个节点，内容为x
iterator insert(iterator position, const T& x) { link_type tmp=create_node(x); //产生一个节点 //调整双向指针，使tmp插入进去 tmp->next=position.node; tmp->prev=position.node->prev; (link_type(position.node->prev)) ->next=tmp; position,node->prev=tmp; return tmp; }
4.3.6 list的元素操作：push_front，push_back，erase，pop_front，pop_back，clear，remove，unique，splice，merge，reverse，sort
push_front & push_back：
void push_front(const T& x) { insert(begin(),x); } void push_back(const T& x) { insert(end(),x); }
erase：
iterator erase(iterator position) { link_type next_node=link_type(position.node->next); link_type prev_node=link_type(position.node->prev); prev_node->next=next_node; next_node->prev=prev_node; destroy_node(position.node); return iterator(next_node); }
pop_front & pop_back：
void pop_front() { erase(begin()); } void pop_back() { iterator tmp=end(); erase(--tmp); }
clear：
template <class T, class Alloc> void list<T, Alloc>::clear(){ link_type cur=(link_type) node->next; while(cur!=node){ link_type tmp=cur; cur=(link_type) cur->next; destroy_node(tmp); } node->next=node; node->prev=node; }
remove：
template <class T, class Alloc> void list<T,Alloc>::remove(const T& value) { iterator first=begin(); iterator last=end(); while(first!=last){ iterator next=first; ++next; if(*first==value) erase(first); //将数值为value的元素移除 first=next; } }
unique：
//移除数值相同的连续元素 //只有"连续而相同的元素"，才会被移除剩一个 template <class T, class Alloc> void list<T,Alloc>::unique(){ iterator first=begin(); iterator last=end(); if(first==last) return; iterator next=first; while(++next!=last){ if(*first==*next) erase(next); else first=next; next=first; } }
transfer：
protected: //将[first, last)内的所有元素移动到position前面 void transfer(iterator position, iterator first,iterator last) { (*(link_type((*last.node).prev))).next=position.node; (*(link_type((*first.node).prev))).next=last.node; (*(link_type((*position.node).prev))).next=first.node; link_type tmp=link_type((*position.node).prev); (*position.node).prev=(*last.node).prev; (*last.node).prev=(*first.node).prev; (*first.node).prev=tmp; } }
splice：
public: //1.将x接合于position所指位置之前。x必须不同于*this void splice(iterator position, list& x){ if(!x.empty()) transfer(position,x.begin(),x.end()); } //2.将i所指元素接合于position所指位置之前。position和i可指向同一个list void splice(iterator position, list&,iterator i){ iterator j=i; ++j; if(position==i || position==j) return; transfer(position,i,j); } //3.将[first, last)内的所有元素接合于position所指位置之前 // position和[first, last)可指向同一个list， // 但position不能位于[first, last)之内 void splice(iterator position, list& ,iterator first, iterator last){ if(first!=last) transfer(position,first,last); }
merge：
//合并两个list，两个list的内容必须先经过递增排序 template <class T, class Alloc> void list<T, Alloc>::merge(list<T,Alloc>& x){ iterator first1=begin(); iterator last1=end(); iterator first2=x.begin(); iterator last2=x.end(); while(first1!=last1 && first2!=last2) { if(*first2<*first1){ iterator next=first2; transfer(first1,first2,++next); first2=next; }else ++first1; } if(first2!=last2) transfer(last1,first2,last2); }
reverse：
template <class T,class Alloc> void list<T,Alloc>::reverse(){ if(node->next == node || link_type(node->next)->next ==node) return; iterator first=begin(); ++first; while(first!=end()){ iterator old=first; ++first; transfer(begin(), old, first); } }
sort：
//由于STL算法sort()只接受RandomAccessIterator //所以list采用自己的sort() ——是quick sort template <class T,class Alloc> void list<T,Alloc>::sort() { if(node->next ==node || link_type(node->next)->next ==node) return; list<T,Alloc> carry; list<T,Alloc> counter[64]; int fill=0; while(!empty()){ carry.splice(carry.begin(),*this,begin()); int i=0; while(i<fill && !counter[i].empty()) { counter[i].merge(carry); carry.swap(counter[i++]); } carry.swap(counter[i]); if(i == fill ) ++fill; } for(int i=1;i<fill;i++) counter[i].merge(counter[i-1]); swap(counter[fill-1]); }
4.4 deque
4.4.1 deque概述
1.deque是双向开口的连续线性空间；
2.deque允许于常数时间内对起头端进行元素的插入或移除操作（vector不能）；
3.deque没有容量概念，它是动态地以分段连续空间组合而成，可以随时增加一段新的空间并链接起来，不必像vector那样配置新空间、复制元素、释放旧空间；
4.deque的迭代器复杂度很高，故尽量使用vector而非deque；
5.对deque进行排序操作，为了最高效率，可将deque先完整复制到一个vector身上，将vector排序后（STL sort算法），再复制回deque。
4.4.2 deque的中控器
deque采用一块map（不是STL的map容器）作为主控，map是一小块连续空间，其中的每个元素（称为节点，node）都是指针，指向另一段（较大的）连续线性空间，称为缓冲区，而缓冲区才是deque的储存空间主体。
template <class T, class Alloc=alloc, size_t BufSiz=0> //BufSiz默认值0，表示将使用512bytes缓冲区 class deque{ public: typedef T value_type; typedef value_type* pointer; ... protected: //元素的指针的指针 typedef pointer* map_pointer; protected: map_pointer map; //指向map，map内的每个元素都是一个指针，指向一块缓冲区 size_type map_size; //map内可容纳多少指针//可见，map其实是一个T** ... }
4.4.3 deque的迭代器
deque迭代器应该具备的结构：
1.能够指出分段连续空间（缓冲区）在哪里；
2.能够判断自己是否已经处于其所在缓冲区的边缘，如果是，一旦前进或后退时就必须跳跃至下一个或上一个缓冲区。
template <class T, class Ref, class Ptr, size_t BufSiz> struct __deque_iterator { //未继承std::iterator typedef __deque_iterator<T,T&,T*,BufSiz> iterator; typedef __deque_iterator<T,const T&,cosnt T*,BufSiz> const_iterator; static size_t buffer_size() { return __deque_buf_size(BufSiz, sizeof(T)); } typedef random_access_iterator_tag iterator_category; typedef T value_type; typedef Ptr pointer; typedef Ref 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） ... }
决定缓冲区大小的函数buffer_size()：
//如果n不为0，传回n，表示buffer_size由用户自定义 //如果n为0，表示buffer size使用默认值，那么 // 如果sz（元素大小，sizeof(value_type)）小于512，传回512/sz， // 如果sz不小于512，传回1 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)); }
迭代器的前进后退：
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; } //直接跳跃n个位置 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; setnode(node+node_offset); cur=first+(offset-node_offset*difference_type(buffer_size())); } return *this; } self operator+(difference_type n) const{ 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; } reference operator[] (difference_type n) 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); }
4.4.4 deque的数据结构
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; public: typedef __deque_iterator<T,T&,T*,BufSiz> iterator; protected: typedef pointer* map_pointer; protected: iterator start; iterator finish; map_pointer map; size_type map_size; ... public: iterator begin() { return start; } iterator end() { return finish; } reference operator[] (size_type n){ return start[difference_type(n)]; } reference front() { return *start; } reference back() { iterator tmp=finish; --tmp; return *tmp; //不用return *(finish-1); //因为没有定义finish-1的运算子 } size_type size() const { return finish-start; } size_type max_size() const { return size_type(-1); } bool empty() const { return finish == start; } }
4.4.5 deque的构造与内存管理：ctor，push_back，push_front
ctor：
/*deque两个专属空间配置器*/ protected: //每次配置一个元素大小 typedef simple_alloc<value_type,Alloc> data_allocator; //每次配置一个指针大小 typedef simple_alloc<pointer,Alloc> map_allocator; ... //ctor deque(int n,const value_type& value) : start(), finish(), map(0), map_size(0) { fill_initialize(n,value); } //fill_initialize()负责产生并安排好deque的结构 //并将元素的初值设定妥当 template <class T, class Alloc, size_t BufSize> void deque<T,Alloc,BufSize>::fill_initialize(size_type n, const value_type& value) { create_map_and_nodes(n); map_pointer cur; __STL_TRY{ for(cur=start.node; cur<finish.node; ++cur) uninitialized_fill(finish.first, finish.cur, value); }catch(...){ ... } } //create_map_and_nodes()负责产生并安排好deque的结构 template <class T, class Alloc, size_t BufSize> void deque<T,Alloc,BufSize>::create_map_and_nodes(size_type num_elements) { //需要节点数=（元素个数/每个缓冲区可容纳的元素个数）+1 //如果刚好整除，会多配一个节点 size_type num_nodes=num_elements/buffer_size()+1; //一个map要管理几个节点 //最少8个，最多是“所需节点数+2”（前后各预留一个） map_size=max(initial_map_size(), num_nodes+2); map=map_allocator::allocate(map_size); map_pointer nstart=map+(map_size-num_nodes)/2; map_pointer nfinish=nstart+num_nodes-1; map_pointer cur; __STL_TRY{ for(cur=nstart; cur<=nfinish; ++cur) *cur=allocate_node(); }catch(...){ ... } start.set_node(nstart); finish.set_node(nfinish); start.cur=start.first; //cur指向前面多分配的一个节点的起始处 finish.cur=finish.first + num_elements%buffer_size()； }
push_back：
public: void push_back(const value_type& t){ if(finish.cur!=finish.last-1){ construct(finish.cur,t); ++finish.cur; }else //最后缓冲区只剩一个元素备用空间 push_back_aux(t); } template <class T,class Alloc,size_t BufSize> void deque<T,Alloc,BufSize>::push_back_aux(const value_type& t){ value_type t_copy=t; reserve_map_at_back(); *(finish.node+1)=allocate_node(); __STL_TRY{ construct(finish.cur, t_copy); finish.set_node(finish.node+1); finish.cur=finish.first; } __STL_UNWIND(deallocate_node(*(finish.node+1))); }
push_front：
public: void push_front(const value_type& t){ if(start.cur!=start.first){ construct(start.cur-1,t); --start.cur; }else //第一缓冲区已无备用空间 push_front_aux(t); } template <class T,class Alloc,size_t BufSize> void deque<T,Alloc,BufSize>::push_front_aux(const value_type& t){ value_type t_copy=t; reserve_map_at_front(); *(start.node-1)=allocate_node(); __STL_TRY{ start.set_node(start.node-1); start.cur=start.last-1; construct(start.cur, t_copy); }catch(...){ start.set_node(start.node+1); start.cur=start.first; deallocate_node(*(start.node-1)); throw; } }
void reserve_map_at_back(size_type nodes_to_add=1){ //如果map尾端的节点备用空间不足 //符合以下条件则必须重换一个map（配置更大的，拷贝原来的，释放原来的） if(nodes_to_add+1>map_size-(finish.node-map)) reallocate_map(nodes_to_add,false); } void reserve_map_at_front(size_type nodes_to_add=1){ //如果map前端的节点备用空间不足 //符合以下条件则必须重换一个map（配置更大的，拷贝原来的，释放原来的） if(nodes_to_add > start.node-map) reallocate_map(nodes_to_add,true); } template <class T,class Alloc, size_t BufSize> void deque<T,Alloc,BufSize>::reallocate_map(size_type nodes_to_add, bool add_at_front){ size_type old_num_nodes=finish.node-start.node+1; size_type new_num_nodes=old_num_nodes+nodes_to_add; map_pointer new_nstart; if(map_size > 2*new_num_nodes){ new_nstart=map+(map_size - new_num_nodes)/2+(add_at_front ? nodes_to_add :0); if(new_nstart<start.node) copy(start.node, finish.node+1, new_nstart); else copy_backward(start.node, finish.node+1, new_nstart+old_num_nodes); }else{ size_type new_map_size=map_size+max(map_size, nodes_to_add)+2; //配置一块空间，准备给新map使用 map_pointer new_map=map_allocator::allocate(new_map_size); new_nstart=new_map+(new_map_size-new_num_nodes)/2 +(add_at_front ? nodes_to_add :0); //把原map内容拷贝过来 copy(start.node, finish.node+1， new_nstart); //释放原map map_allocator::deallocate(map, map_size); //设定新map的起始地址与大小 map=new_map; map_size=new_map_size; } start.set_node(new_nstart); finish.set_node(new_nstart+old_num_nodes-1); }
4.4.6 deque的元素操作：pop_back，pop_front，clear，erase，insert
pop_back：
void pop_back(){ if(finish.cur!=finish.first){ --finish.cur; destroy(finish.cur); }else pop_back_aux(); } template <class T,class Alloc, size_t BufSize> void deque<T,Alloc,BufSize>::pop_back_aux(){ deallocate_node(finish.first); finish.set_node(finish.node-1); finish.cur=finish.last-1; destroy(finish.cur); }
pop_front：
void pop_front(){ if(start.cur!=start.last-1){ destroy(start.cur); ++start.cur; }else pop_front_aux(); } template <class T,class Alloc, size_t BufSize> void deque<T,Alloc,BufSize>::pop_front_aux(){ destroy(start.cur); deallocate_node(start.first); start.set_node(start.node+1); start.cur=start.first; }
clear：
//恢复到初始状态，保留一个缓冲区 template <class T,class Alloc,size_t BufSize> void deque<T,Alloc,BufSize>::clear(){ for(map_pointer node=start.node+1; node<finish.node; ++node){ destroy(*node,*node+buffer_size()); data_allocator::deallocator(*node, buffer_size()); } if(start.node!=finish.node){ destroy(start.cur, start.last); destroy(finish.first, finish.cur); data_allocator::deallocate(finish.first, buffer_size()); }else destroy(start.cur, finish.cur); finish=start; }
erase：
//清除pos所指元素iterator erase(iterator pos){ iterator next=pos; ++next; difference_type index=pos-start; if(index< (size() >>1)){ //index< size()/2 copy_backward(start,pos,next); pop_front(); }else{ copy(next, finish, pos); pop_back(); } return start+index; }
//清除[first,last)区间内的所有元素 template <class T,class Alloc,size_t BufSize> deque<T,Alloc,BufSize>::iterator deque<T,Alloc,BufSize>::erase(iterator first,iterator last){ if(first==start && last==first){ //如果清除的区间就是整个deque clear(); return finish; }else{ difference_type n=last-first; difference_type elems_before=first-start; if(elems_before<(size()-n)/2){ //如果前方的元素比较少 copy_backward(start, first, last); //向后移动前方元素（覆盖清除区间） iterator new_start=start+n; destroy(start, new_start); for(map_pointer cur=start.node; cur<new_start.node; ++cur) data_allocator::deallocate(*cur, buffer_size()); start=new_start; }else{ //如果后方的元素比较多 copy(last, finish, first); //向前移动后方元素（覆盖清除区间）） iterator new_finish=finish-n; destroy(new_finish, finish); for(map_pointer cur=new_finish.node; cur<=finish.node; ++cur) data_allocator::deallocate(*cur, buffer_size()); finish=new_finish; } return start + elems_before; } }
insert：
iterator insert(iterator position, const value_type& x){ if(position.cur==start.cur){ //插入点是deque最前端 push_front(x); return start; }else if(position.cur == finish.cur){ //插入点是deque最尾端 push_back(x); iterator tmp=finish; --tmp; return tmp; }else{ return insert_aux(position,x); } } template <class T,class Alloc, size_t BufSize> typename deque<T,Alloc,BufSize>::iterator deque<T,Alloc,BufSize>::insert_aux(iterator pos,const value_type x){ difference_type index=pos-start; value_type x_copy=x; if(index<size()/2){ //插入点之前的元素个数比较少 push_front(front()); //在最前端加入与首元素同值的元素 iterator front1=start; ++front1; iterator front2=front1; ++front2; pos=start+index; iterator pos1=pos; ++pos1; copy(front2,pos1,front1); //区间front2到pos1的元素复制到front1后面 }else{ //插入点之后的元素个数比较少 push_back(back()); iterator back1=finish; --back1; iterator back2=back1; --back2; pos=start+index; copy(pos,back2,back1); } *pos=x_copy; //在插入点上设定新值 return pos; }
4.5 stack
4.5.1 stack概述
stack是一种FILO数据机构，只有一个出口，stack允许新增元素（push）、移除元素（pop）、取得最顶端元素。
由于stack只有顶端元素才能被外界取用，stack不提供走访功能，故stack不能遍历、不提供迭代器。
4.5.2 stack定义完整列表
以某种既有容器作为底部结构，将其接口改变，使之符合“先进后出”的特性，形成一个stack。
而stack这种“修改某物接口，形成另一种风貌”的称为adapter（配接器），stack不被归类为container，而被归类为container adapter。
如以deque为底部结构的stack：
template <class T, class Sequence=deque<T> > class stack{ friend bool operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&); friend bool operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&); public: typedef typename Sequence::value_type value_type; typedef typename Sequence::size_type size_type; typedef typename Sequence::reference reference; typedef typename Sequence::const_reference const_reference; protected: Sequence c; //底层容器 public: bool empty() const{ return c.empty(); } size_type size() const { return c.size(); } reference top() { return c.back(); } const_reference top() const { return c.back(); } void push(const value_type& x) { c.push_back(x); } void pop() { c.pop_back(); } }; template< <class T, class Sequence> bool operator==(const stack<T,Sequence>& x,const stack<T,Sequence>& y){ return x.c==y.c; } template< <class T, class Sequence> bool operator<(const stack<T,Sequence>& x,const stack<T,Sequence>& y){ return x.c<y.c; }
4.5.4 以list作为stack的底层容器
#include <stack> #include <list> #include <iostream> #include <algorithm> using namespace std; int main(){ stack<int, list<int> > istack; istack.push(1); istack.push(3); cout<<istck.size()<<endl; //2 cout<<istack.top()<<endl; //3 istack.pop(); cout<<istack.top()<<endl; //1 cout<<istack.size()<<endl; //1 }
4.6 queue
4.6.1 queue概述
对比stack，queue是FIFIO的数据结构（其他性质与stack一样）。
4.6.2 queue定义完整列表
以deque为底部结构的queue：
template <class T, class Sequence=deque<T> > class queue{ friend bool operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&); friend bool operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&); public: typedef typename Sequence::value_type value_type; typedef typename Sequence::size_type size_type; typedef typename Sequence::reference reference; typedef typename Sequence::const_reference const_reference; protected: Sequence c; //底层容器 public: bool empty() const{ return c.empty(); } size_type size() const { return c.size(); } //以下部分与stack不同 reference front() { return c.front(); } const_reference front() const { return c.front(); } reference back() { return c.back(); } const_reference back() const { return c.back(); } void push(const value_type& x) { c.push_back(x); } void pop() { c.pop_front(); } }; template< <class T, class Sequence> bool operator==(const stack<T,Sequence>& x,const stack<T,Sequence>& y){ return x.c==y.c; } template< <class T, class Sequence> bool operator<(const stack<T,Sequence>& x,const stack<T,Sequence>& y){ return x.c<y.c; }
4.6.4 以list作为queue的底层容器
（和4.5.4一样）
