STL源码剖析(deque)

deque是一个双向开口的容器，在头尾两端进行元素的插入跟删除操作都有理想的时间复杂度。

deque使用的是分段连续线性空间，它维护一个指针数组(T** map)，其中每个指针指向一块连续线性空间。

(map左右两边一般留有剩余空间，用于前后插入元素，具体下面可以看到其实现)

 

根据上图，可以了解到deque的迭代器的基本定义。

template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator {
    // 基本型别的定义
    typedef __deque_iterator<T, T&, T*, BufSiz>             iterator;
    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;

    // 缓冲区的大小
    tatic size_t buffer_size() { ... }    

    // 主要维护的三个指针
    T* cur;    // 指向当前元素
    T* first;   // 指向当前缓冲区的头
    T* last;   // 指向当前缓冲区的尾

    map_pointer node; // 指向当前缓冲区在map中的位置
    // ...
};

 

deque的实现基本都是依赖于其迭代器的实现(主要是各种操作符的重载)

// 用于跳到下一个缓冲区
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*()); }

self& operator++() {
    ++cur;
    if (cur == last) {  // 到达缓冲区尾端
        set_node(node + 1);
        cur = first;
    }
    return *this; 
}

self& operator--() {
    if (cur == first) { // 已到达缓冲区头端
        set_node(node - 1);
        cur = last;
    }
    --cur;
    return *this;
}

// 迭代器之间的距离(相隔多少个元素)
difference_type operator-(const self& x) const {
    return difference_type(buffer_size()) * (node - x.node - 1) +
      (cur - first) + (x.last - x.cur);
}

该迭代器还重载了operator+=、operator+、operator-=、operator-(difference_type)等，

都是通过set_node()跟调整cur、first、last、node成员来实现。同时重载的operator[]使用operator+来进行随机存取。

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指针
        cur = first + (offset - node_offset * difference_type(buffer_size()));
    }
    return *this;
}

// 下面的都直接或间接的调用operator+=
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); }    

 

有了__deque_iterator，deque的基本实现就比较简单了(主要维护start、finish这两个迭代器)

下面是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;
    typedef pointer* map_pointer;
public:
    typedef __deque_iterator<T, T&, T*, BufSiz>  iterator;
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)]; } // 调用迭代器重载的operator[]
   
    // ...
}

deque的constructor会调用create_map_and_nodes()来初始化map

// 每次配置一个元素大小的配置器
typedef simple_alloc<value_type, Alloc> data_allocator;
// 每次配置一个指针大小的配置器
typedef simple_alloc<pointer, Alloc> map_allocator;

template <class T, class Alloc, size_t BufSize>
void deque<T, Alloc, BufSize>::create_map_and_nodes(size_type num_elements) {
    // 需要分配的结点数  如果为能整除 则多分配多一个结点
    size_type num_nodes = num_elements / buffer_size() + 1;

    // 分配结点内存 (前后预留一个 用于扩充)
    map_size = max(initial_map_size(), num_nodes + 2);
    map = map_allocator::allocate(map_size);

    // 将需要分配缓冲区的结点放在map的中间
    map_pointer nstart = map + (map_size - num_nodes) / 2;
    map_pointer nfinish = nstart + num_nodes - 1;
    
    map_pointer cur;
    // 为了简化 去掉了异常处理的代码
    for (cur = nstart; cur <= nfinish; ++cur)
        *cur = allocate_node(); // 为每个结点分配缓冲区
    }

    // 设置start、finish指针
    start.set_node(nstart);
    finish.set_node(nfinish);
    start.cur = start.first;
    finish.cur = finish.first + num_elements % buffer_size();
}

 

下面就剩下插入跟删除元素的实现了，首先看看关于push_front()的操作的实现。

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();   // 可能导致map的重新整治
    *(start.node - 1) = allocate_node();
    start.set_node(start.node - 1);
    start.cur = start.last - 1;
    construct(start.cur, t_copy);
} 

// 根据map前面为分配的结点数量来判断是否需要重新整治
void reserve_map_at_front (size_type nodes_to_add = 1) {
    if (nodes_to_add > start.node - map)
        reallocate_map(nodes_to_add, true);
}

上面留下的reallocate_map函数执行如下功能:

1.如果map中空闲指针足够多，则将已分配的结点移到map的中间。

2.否则重新分配一个map，将旧的map释放，把已分配的结点移到new_map的中间。

然后调整start跟finish迭代器。

 

然后是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;
}      

 

而push_back()跟pop_back()的实现跟上面的大同小异。

最后看看erase()跟insert()的实现

iterator erase(iterator pos) {
    iterator next = pos;
    ++next;
    difference_type index = pos - start; // 迭代器的operator-
    if (index < (size() >> 1)) { // 如果清除点之前的元素比较少
        // 将清除点之前的所有元素后移一位  然后删除第一个元素
        copy_backward(start, pos, next);  // 利用了迭代器的operator--
        pop_front();
    }
    else { // 如果清除点之后的元素比较少
        // 将清除点之后的所有元素前移一位  然后删除最后一个元素
        copy(next, finish, pos);  // 利用了迭代器的operator++
        pop_back();
    }
    return start + index;
}

iterator insert(iterator position, const value_type& x) {
    if (position.cur == start.cur) {
        // 插入位置为begin()
        push_front(x);
        return start;
    }
    else if (position.cur == finish.cur) {
        // 插入位置为end()
        push_back(x);
        iterator tmp = finish;
        --tmp;
        return tmp;
    }
    else {
        // 如果插入位置是在(begin(), end())
        return insert_aux(position, x);
    }
}

// insert_aux()跟erase()实现类似
// 调用copy()或者copy_backward()将元素前移或者后移
// 然后修改原来位置的值