STL源码剖析——deque的实现

deque简介

deque是一个双向开口的容器，可在头尾两端插入和删除元素，deque由动态的连续空间组合而成，因为迭代器的良好设计，提供了随机访问，造成一种deque为连续空间的假象

deque的数据结构

deque有一个二级指针map，map指向一小块空间，其中的每个元素都是指针，指向一段连续线性空间，称为缓冲区，缓冲区为deque存储的主体，其中存放元素

tempalte <class T, class Alloc = alloc>class deque {public:    typedef T   value_type;    typedef T*  pointer;    typedef T** map_pointer;protected:    iterator  start;    iterator  finish;    map_pointer map;    size_type size;         //map内指针个数    ......}

iterator 结构如下:

template <class T>class deque_iterator {public:    typedef T**    map_pointer;    T*  cur;            //指向所指缓冲区当前元素    T*  first;          //首元素    T*  last;           //尾元素后一个    map_pointer node;   //指向控制中心}    

用图表示如下

deque的主要操作

1.push_front

当start指向的缓冲区无备用空间时，执行push_front_aux
push_front_aux操作如下：
判断map前端的备用节点是否充足，如果充足，则再分配一个缓冲区，start.node - 1指向它，然后改节点，构造元素即可
如果map前端备用节点不足，如果map_size够大，则并不需要重新分配map， 只需要移动map中的元素即可，最后重置start, finish迭代器即可
如果map_size不够大，则要重新分配map

2.push_back

操作与push_front类似

3.pop_front

void pop_front() {    if (start.cur != start.last - 1) {        //第一缓冲区有多个元素        destroy(start.cur);        ++start.cur;    }    else        pop_front_aux();}void pop_front_aux() {    destroy(start.cur);    deallocate_node(start.first);      //回收缓冲区空间    start.set_node(start.node + 1);    //重置迭代器    start.cur = start.first;}

4.pop_back

void pop_back() {    if (finish.cur != finish.first) {        //最后缓冲区有元素        --finish.cur;        destroy(finish.cur);    }    else        pop_back_aux();}void pop_back_aux() {    deallocate_node(finish.first);    //回收缓冲区空间    finish.set_node(finish.node - 1); //重置迭代器    finish.cur = finish.last - 1;    destroy(finish.cur);}

deque迭代器完整实现

template <class T>class deque_iterator {public:    typedef deque_iterator<T>           iterator;    typedef random_access_iterator_tag  iterator_category;    typedef T                           value_type;    typedef T*                          pointer;    typedef T&                          reference;    typedef ptrdiff_t                   difference_type;    typedef T**                         map_pointer;    typedef deque_iterator              self;    T*  cur;            //指向所指缓冲区当前元素    T*  first;          //首元素    T*  last;           //尾元素后一个    map_pointer node;   //指向控制中心    deque_iterator():cur(0), first(0), last(0), node(0){}    deque_iterator(const deque_iterator& other):        cur(other.cur), first(other.first), last(other.last), node(other.node){}  static size_t buffer_size() {       return deque_buffer_size(sizeof(T));   }   //重新设置指向管控中心的指针，修改first, last指向缓冲区   void set_node(map_pointer new_node) {       node = new_node;       first = *new_node;       last = *new_node + (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 temp = *this;       ++*this;       return temp;   }   //前置--   self& operator-- () {       if (cur == first) {           set_node(node - 1);           cur = last;       }       --cur;       return *this;   }   //后置--   self operator-- (int) {       self temp = *this;       --*this;       return temp;   }   //实现随机存取   self& operator+= (difference_type n) {       difference_type offset = n + cur - first;       size_t size = buffer_size();       if (offset >= 0 && offset < size)           cur += n;       else {           //不在同一缓冲区内           difference_type node_offset = offset > 0 ?               offset / size :               -difference_type((-offset - 1) / size) - 1;           //重置node,设置cur指向           set_node(node + node_offset);           cur = first + (offset - node_offset * size);//offset正负都适用       }       return *this;   }   self operator+ (difference_type n) const {       self temp = *this;       return temp += n;   }   self& operator-= (difference_type n) {       return *this += -n;   }   self operator- (difference_type n) const {       self temp = *this;       return temp -= n;   }   //重载[]，随机存取   reference operator[] (difference_type n) const {       return *(*this + n);   }   bool operator== (const self& x) { return cur == x.cur; }   bool operator!= (const self& x) { return cur != x.cur; }   bool operator< (const self& x) {       return (node == x.node) ? (cur < x.cur) : (node < x.node);   }};

为了将deque的迭代器使用起来看似是普通指针需要费些功夫

小结：

由deque的构造我们可以很自然的想到，用deque作为底层容器来实现stack，queue，对于stack，queue的所有操作只需要对deque转调用即可