STL源码剖析---deque

转载 2016年08月31日 13:57:40

一、deque的中控器

      deque是连续空间(至少逻辑上看来如此),连续线性空间总令我们联想到arrayvectorarray无法成长,vector虽可成长,却只能向尾端成长,而且其所谓的成长原是个假象,事实上是(1)另觅更大空间;(2)将原数据复制过去;(3)释放原空间三部曲。如果不是vector每次配置新空间时都有留下一些余裕,其成长假象所带来的代价将是相当高昂。

      deque系由一段一段的定量连续空间构成。一旦有必要在deque的前端或尾端增加新空间,便配置一段定量连续空间,串接在整个deque的头端或尾端。deque的最大任务,便是在这些分段的定量连续空间上,维护其整体连续的假象,并提供随机存取的借口。避开了“重新配置、复制、释放”的轮回,代价则是复杂的迭代器架构。

      受到分段连续线性空间的字面影响,我们可能以为deque的实现复杂度和vector相比虽不中亦不远矣,其实不然。主要因为,既是分段连续线性空间,就必须有中央控制,而为了维持整体连续的假象,数据结构的设计及迭代器前进后退等操作都颇为繁琐。deque的实现代码分量远比vectorlist都多得多。

      deque采用一块所谓的map(注意,不是STLmap容器)作为主控。这里所谓map是一小块连续空间,其中每个元素(此处称为一个节点,node)都是指针,指向另一段(较大的)连续线性空间,称为缓冲区。缓冲区才是deque的储存空间主体。SGI STL 允许我们指定缓冲区大小,默认值0表示将使用512 bytes 缓冲区。

二、deque的迭代器

      让我们思考一下,deque的迭代器应该具备什么结构,首先,它必须能够指出分段连续空间(亦即缓冲区)在哪里,其次它必须能够判断自己是否已经处于其所在缓冲区的边缘,如果是,一旦前进或后退就必须跳跃至下一个或上一个缓冲区。为了能够正确跳跃,deque必须随时掌握管控中心(map)。所以在迭代器中需要定义:当前元素的指针,当前元素所在缓冲区的起始指针,当前元素所在缓冲区的尾指针,指向map中指向所在缓区地址的指针。

在进行迭代器的移动时,需要考虑跨缓冲区的情况。

重载前加(),在实现后加()时,调用重载的前加()

重载+=,实现+时,直接调用+=,实现-=时,调用+=负数,实现-时,调用-=.

//当需要实现新的功能时,最好使用已经重载好的操作,即方便有安全。。。。

另外,deque在效率上来说是不够vector好的,因此有时候在对deque进行sort的时候,需要先将元素移到vector再进行sort,然后移回来。

 

构造函数:根据缓冲区设置大小和元素个数,决定map的大小;给map分配空间,根据缓冲区的个数,分配缓冲区,默认指定一个缓冲区;

 设置startfinish迭代器,满足左闭右开的原则。

 push_back:如果空间满足,直接插入;不满足,调用push_back_aux

 push_back_aux:先调用reverse_map_at_back,若符合某种条件,重换一个map;分配空间。

 reserve_map_at_back:看看map有没有满,满的话,调用reallocate_map

 reallocate_map:如果前端或后端pop过多,就会导致大量的空闲空间,如果是这种情况,则不用新分配空间,调整一下start的位置即可;

 如果不够,则需要重新申请空间。

 pop:析构元素,如果是最后一块还需要删除空间。

 erase:需要判断,前面的元素少还是后面的元素少,移动较少的部分。

 insert:判断位置,如果为前端或后端直接调用push操作,否则,移动较少的一端。

deque的构造与内存管理:

由于deque的设计思想就是由一块块的缓存区连接起来的,因此它的内存管理会比较复杂。插入的时候要考虑是否要跳转缓存区、是否要新建map节点(和vector一样,其实是重新分配一块空间给map,删除原来空间)、插入后元素是前面元素向前移动还是后面元素向后面移动(谁小移动谁)。而在删除元素的时候,考虑是将前面元素后移覆盖需要移除元素的地方还是后面元素前移覆盖(谁小移动谁)。移动完以后要析构冗余的元素,释放冗余的缓存区。 

三、deque的源码剖析

[cpp] view plain copy

//   deque的特性:  

//   对于任何一个迭代器i  

//     i.nodemap array中的某元素的地址. i.node的内容是一个指向某个结点的头的指针  

//     i.first == *(i.node)  

//     i.last  == i.first + node_size  

//     i.cur是一个指向[i.first, i.last)之间的指针  

//       注意这意味着i.cur永远是一个可以解引用的指针,  

//            即使其是一个指向结尾后元素的迭代器  

//  

//   起点和终点总是非奇异(nonsingular)的迭代器.  

//     注意这意味着空deque一定有一个node, 而一个具有N个元素的deque  

//          (NBuffer Size)一定有有两个nodes  

//  

//   对于除了start.nodefinish.node之外的每一个node, 每一个node中的元素  

//   都是一个初始化过的对象如果start.node == finish.node,  

//   那么[start.cur, finish.cur)都是未初始化的空间.  

//   否则, [start.cur, start.last)[finish.first, finish.cur)都是初始化的对象,  

//   [start.first, start.cur)[finish.cur, finish.last)是未初始化的空间  

//  

//   [map, map + map_size)是一个合法的非空区间  

//   [start.node, finish.node]是内含在[map, map + map_size)区间的合法区间  

//   一个在[map, map + map_size)区间内的指针指向一个分配过的node,  

//   当且仅当此指针在[start.node, finish.node]区间内  

  

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));    

}  

  

// __deque_iterator的数据结构  

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

struct __deque_iterator  

{  

    typedef __deque_iterator<T, T&, T*>             iterator;  

    typedef __deque_iterator<T, const T&, const T*> const_iterator;  

    static size_t buffer_size() {return __deque_buf_size(0, 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;    // 指向管控中心  

  

////////////////////////////////////////////////////////////////////////////////  

// 这个是deque内存管理的关键其模型如下  

////////////////////////////////////////////////////////////////////////////////  

//  

//       ---------------------------------------------  

// map-->|   |   |   |   |   |   | ..... |   |   |   |<------------------  

//       ---------------------------------------------                  |  

//             |                                                        |  

//             |                                                        |  

//             |   node                                                 |  

//             |   缓冲区buffer, 这里实际存储元素                          |  

//             |   ---------------------------------------------        |  

//             --->|   |   |   |   |   |   | ..... |   |   | X |        |  

//                 ---------------------------------------------        |  

//                   ↑       ↑                             ↑            |  

//             ------        |                             |            |  

//             |             |                             |            |  

//             |   -----------   ---------------------------            |  

//             ----|-----        |                                      |  

//                 |    |        |                                      |  

//                 |    |        |                                      |  

//                 |    |        |                                      |  

//              ---------------------------                             |  

//              | cur | first | end | map |------------------------------  

//              ---------------------------  

//              迭代器其内部维护着一个缓冲区状态  

////////////////////////////////////////////////////////////////////////////////  

    __deque_iterator(T* x, map_pointer y)  

        : cur(x), first(*y), last(*y + buffer_size()), node(y) {}  

    __deque_iterator() : cur(0), first(0), last(0), node(0) {}  

    __deque_iterator(const iterator& x)  

        : cur(x.cur), first(x.first), last(x.last), node(x.node) {}  

  

    reference operator*() const { return *cur; }  

  

    // 判断两个迭代器间的距离  

    difference_type operator-(const self& x) const  

    {  

        return difference_type(buffer_size()) * (node - x.node - 1) +  

            (cur - first) + (x.last - x.cur);  

    }  

  

////////////////////////////////////////////////////////////////////////////////  

// 下面重载的这些运算符是让deque从外界看上去维护的是一段连续空间的关键!!!  

  

// 前缀自增  

////////////////////////////////////////////////////////////////////////////////  

// 如果当前迭代器指向元素是当前缓冲区的最后一个元素,  

// 则将迭代器状态调整为下一个缓冲区的第一个元素  

////////////////////////////////////////////////////////////////////////////////  

// 不是当前缓冲区最后一个元素  

//  

// 执行前缀自增前的状态  

// first          cur                     end  

// ↓               ↓                       ↓  

// ---------------------------------------------  

// |   |   |   |   |   |   | ..... |   |   | X | <----- 当前缓冲区  

// ---------------------------------------------  

//  

// 执行完成后的状态  

// first              cur                 end  

// ↓                   ↓                   ↓  

// ---------------------------------------------  

// |   |   |   |   |   |   | ..... |   |   | X | <----- 当前缓冲区  

// ---------------------------------------------  

//  

////////////////////////////////////////////////////////////////////////////////  

// 当前元素为当前缓冲区的最后一个元素  

//  

// 执行前缀自增前的状态  

// first                              cur end  

// ↓                                   ↓   ↓  

// ---------------------------------------------  

// |   |   |   |   |   |   | ..... |   |   | X | <----- 当前缓冲区  

// ---------------------------------------------  

//  

// 执行完成后的状态  

// first                                  end  

// ↓                                       ↓  

// ---------------------------------------------  

// |   |   |   |   |   |   | ..... |   |   | 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个元素, n可以为负  

////////////////////////////////////////////////////////////////////////////////  

//                     operator+=(difference_type n)  

//                                   ↓  

//                      offset = n + (cur - first)  

//                                   |  

//                                   |---------- offset > 0 ? &&  

//                                   |           移动后是否超出当前缓冲区?  

//               ----------------------------  

//           No  |                          |  Yes  

//               |                          |  

//               ↓                          |---------- offset > 0?  

//           cur += n;                      |  

//                              ----------------------------  

//                          Yes |                          | No  

//                              |                          |  

//                              ↓                          |  

//                   计算要向后移动多少个缓冲区                |  

//                   node_offset =                         |  

//                   offset / difference_type              |  

//                   (buffer_size());                      ↓  

//                              |           计算要向前移动多少个缓冲区  

//                              |           node_offset = -difference_type  

//                              |           ((-offset - 1) / buffer_size()) - 1;  

//                              |                          |  

//                              ----------------------------  

//                                           |  

//                                           |  

//                                           ↓  

//                                       调整缓冲区  

//                              set_node(node + node_offset);  

//                                    计算并调整cur指针  

////////////////////////////////////////////////////////////////////////////////  

    // 以下实现随机存取。迭代器可以直接跳跃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;  

            // 切换至正确的节点(亦即缓冲区)  

            set_node(node + node_offset);  

            // 切换至正确的元素  

            cur = first + (offset - node_offset * difference_type(buffer_size()));  

        }  

        return *this;  

    }  

  

    self operator+(difference_type n) const  

    {  

        self tmp = *this;  

  

        // 这里调用了operator +=()可以自动调整指针状态  

        return tmp += n;  

    }  

  

    // n变为-n就可以使用operator +=(),  

    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);  

    }  

  

    void set_node(map_pointer new_node)  

    {  

        node = new_node;  

        first = *new_node;  

        last = first + difference_type(buffer_size());  

    }  

};  

  

  

// deque的数据结构  

template <class T, class Alloc = alloc, size_t BufSiz = 0>  

class deque  

{  

public:                         // Basic types  

    typedef T value_type;  

    typedef value_type* pointer;  

    typedef value_type& reference;  

    typedef size_t size_type;  

    typedef ptrdiff_t difference_type;  

  

public:                         // Iterators  

    typedef __deque_iterator<T, T&, T*, BufSiz>       iterator;  

  

protected:                      // Internal typedefs  

  

    typedef pointer* map_pointer;  

  

    // 这个提供STL标准的allocator接口<stl_alloc.h>  

    typedef simple_alloc<value_type, Alloc> data_allocator;  

    typedef simple_alloc<pointer, Alloc> map_allocator;  

  

    // 获取缓冲区最大存储元素数量  

    static size_type buffer_size()  

    {  

        return __deque_buf_size(BufSiz, sizeof(value_type));  

    }  

  

    static size_type initial_map_size() { return 8; }  

  

protected:                      // Data members  

    iterator start;               // 起始缓冲区  

    iterator finish;              // 最后一个缓冲区  

  

    // 指向map, map是一个连续的空间其每个元素都是一个指针,指向一个节点(缓冲区)  

    map_pointer map;  

    size_type map_size;   // map容量  

  

public:  

    iterator begin() { return start; }  

    iterator end() { return finish; }  

  

    // 提供随机访问能力其调用的是迭代器重载的operator []  

    // 其实际地址需要进行一些列的计算效率有损失  

    reference operator[](size_type n) { return start[difference_type(n)]; }  

  

    reference front() { return *start; }  

    reference back()  

    {  

        iterator tmp = finish;  

        --tmp;  

        return *tmp;  

    }  

  

    // 当前容器拥有的元素个数调用迭代器重载的operator -  

    size_type size() const { return finish - start;; }  

    size_type max_size() const { return size_type(-1); }  

  

    // deque为空的时只有一个缓冲区  

    bool empty() const { return finish == start; }  

  

public:                         // Constructor, destructor.  

    deque() : start(), finish(), map(0), map_size(0)  

    {  

        create_map_and_nodes(0);  

    }  

  

    deque(size_type n, const value_type& value)  

        : start(), finish(), map(0), map_size(0)  

    {  

        fill_initialize(n, value);  

    }  

  

    deque(int n, const value_type& value)  

        : start(), finish(), map(0), map_size(0)  

    {  

        fill_initialize(n, value);  

    }  

  

  

    ~deque()  

    {  

        destroy(start, finish);     // <stl_construct.h>  

        destroy_map_and_nodes();  

    }  

  

    deque& operator= (const deque& x)  

    {  

        // 其实我觉得把这个操作放在if内效率更高  

        const size_type len = size();  

        if (&x != this)  

        {  

            // 当前容器比x容器拥有元素多析构多余元素  

            if (len >= x.size())  

                erase(copy(x.begin(), x.end(), start), finish);  

            // x所有超出部分的元素使用insert()追加进去  

            else {  

                const_iterator mid = x.begin() + difference_type(len);  

                copy(x.begin(), mid, start);  

                insert(finish, mid, x.end());  

            }  

        }  

        return *this;  

    }  

  

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);  

    }  

  

    void push_front(const value_type& t)  

    {  

        if (start.cur != start.first)      // 第一缓冲区尚有备用空间  

        {  

            construct(start.cur - 1, t);   // 直接在备用空间上构造元素  

            --start.cur;     // 调整第一缓冲区的使用状态  

        }  

        else    // 第一缓冲区已无备用空间  

            push_front_aux(t);  

    }  

  

    void pop_back()  

    {  

        if (finish.cur != finish.first)    // 最后缓冲区有一个(或更多)元素  

        {  

            --finish.cur;    // 调整指针,相当于排除了最后元素  

            destroy(finish.cur);    // 将最后元素析构  

        }  

        else  

            // 最后缓冲区没有任何元素  

            pop_back_aux();    // 这里将进行缓冲区的释放工作  

    }  

  

    void pop_front()  

    {  

        if (start.cur != start.last - 1)    // 第一缓冲区有两个(或更多)元素  

        {  

            destroy(start.cur);    // 将第一元素析构  

            ++start.cur;           //调整指针,相当于排除了第一元素  

        }  

        else  

            // 第一缓冲区仅有一个元素  

            pop_front_aux();    // 这里将进行缓冲区的释放工作  

    }  

  

public:                         // Insert  

  

////////////////////////////////////////////////////////////////////////////////  

// 在指定位置前插入元素  

////////////////////////////////////////////////////////////////////////////////  

//             insert(iterator position, const value_type& x)  

//                                   |  

//                                   |---------------- 判断插入位置  

//                                   |  

//               -----------------------------------------------  

// deque.begin() |          deque.emd() |                      |  

//               |                      |                      |  

//               ↓                      ↓                      |  

//         push_front(x);         push_back(x);                |  

//                                                             ↓  

//                                                 insert_aux(position, x);  

//                                                 具体剖析见后面实现  

////////////////////////////////////////////////////////////////////////////////  

  

    iterator insert(iterator position, const value_type& x)  

    {  

        // 如果是在deque的最前端插入那么直接push_front()即可  

        if (position.cur == start.cur)  

        {  

            push_front(x);  

            return start;  

        }  

        // 如果是在deque的末尾插入直接调用push_back()  

        else if (position.cur == finish.cur)  

        {  

            push_back(x);  

            iterator tmp = finish;  

            --tmp;  

            return tmp;  

        }  

        else  

        {  

            return insert_aux(position, x);  

        }  

    }  

  

    iterator insert(iterator position) { return insert(position, value_type()); }  

  

    // 详解见实现部分  

    void insert(iterator pos, size_type n, const value_type& x);  

  

    void insert(iterator pos, int n, const value_type& x)  

    {  

        insert(pos, (size_type) n, x);  

    }  

    void insert(iterator pos, long n, const value_type& x)  

    {  

        insert(pos, (size_type) n, x);  

    }  

  

    void resize(size_type new_size) { resize(new_size, value_type()); }  

  

public:                         // Erase  

  

    iterator erase(iterator pos)  

    {  

        iterator next = pos;  

        ++next;  

  

        // 清除点之前的元素个数  

        difference_type index = pos - start;  

  

        // 如果清除点之前的元素个数比较少哪部分少就移动哪部分  

        if (index < (size() >> 1))  

        {  

            // 就移动清除点之前的元素  

            copy_backward(start, pos, next);  

            pop_front();   // 移动完毕,最前一个元素冗余,去除之  

        }  

        else   // 如果清除点之后的元素个数比较少  

        {  

            copy(next, finish, pos);  // 就移动清除点之后的元素  

            pop_back();   // 移动完毕,最后一个元素冗余,去除之  

        }  

        return start + index;  

    }  

  

    iterator erase(iterator first, iterator last);  

    void clear();  

  

protected:  

  

    // 详解见实现部分  

    void push_back_aux(const value_type& t);  

    void push_front_aux(const value_type& t);  

    void pop_back_aux();  

    void pop_front_aux();  

  

    iterator insert_aux(iterator pos, const value_type& x);  

    void insert_aux(iterator pos, size_type n, const value_type& x);  

  

    // 分配内存不进行构造  

    pointer allocate_node() { return data_allocator::allocate(buffer_size()); }  

  

    // 释放内存不进行析构  

    void deallocate_node(pointer n)  

    {  

        data_allocator::deallocate(n, buffer_size());  

    }  

  

};  

  

  

////////////////////////////////////////////////////////////////////////////////  

// 清除[first, last)区间的所有元素  

////////////////////////////////////////////////////////////////////////////////  

//                  erase(iterator first, iterator last)  

//                                   |  

//                                   |---------------- 是否要删除整个区间?  

//                                   |  

//               ------------------------------------------  

//           Yes |                                        | No  

//               |                                        |  

//               ↓                                        | --- 判断哪侧元素少  

//            clear();                                    ↓  

//       -----------------------------------------------------------------  

// 左侧少 |                                                         右侧少 |  

//       |                                                               |  

//       ↓                                                               ↓  

//   copy_backward(start, first, last);            copy(last, finish, first);  

//   new_start = start + n;                        new_finish = finish - n;  

//   析构多余的元素                                  析构多余的元素  

//   destroy(start, new_start);                    destroy(new_finish, finish);  

//   释放多余内存空间                                释放多余内存空间  

//   for (...)                                     for (...)  

//      ...                                             ...  

//   更新map状态                                    更新map状态  

////////////////////////////////////////////////////////////////////////////////  

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 == finish)   // 如果清除区间是整个deque  

    {  

        clear();              // 直接调用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;     // 标记deque的新起点  

            destroy(start, new_start);          // 移动完毕,将冗余的元素析构  

            // 以下将冗余的缓冲区释放  

            for (map_pointer cur = start.node; cur < new_start.node; ++cur)  

                data_allocator::deallocate(*cur, buffer_size());  

            start = new_start;   // 设定deque的新起点  

        }  

        else    // 如果清除区间后方的元素个数比较少  

        {  

            copy(last, finish, first);  // 向前移动后方元素(覆盖清除区间)  

            iterator new_finish = finish - n;     // 标记deque的新尾点  

            destroy(new_finish, finish);          // 移动完毕,将冗余的元素析构  

            // 以下将冗余的缓冲区释放  

            for (map_pointer cur = new_finish.node + 1; cur <= finish.node; ++cur)  

                data_allocator::deallocate(*cur, buffer_size());  

            finish = new_finish;   // 设定deque的新尾点  

        }  

        return start + elems_before;  

    }  

}  

  

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::deallocate(*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;   // 调整状态  

}  

  

  

// 只有当finish.cur == finish.last - 1 时才会被调用  

// 也就是说,只有当最后一个缓冲区只剩下一个备用元素空间时才会被调用  

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,令其指向新节点  

        finish.cur = finish.first;             // 设定finish的状态  

    }  

    __STL_UNWIND(deallocate_node(*(finish.node + 1)));  

}  

  

// Called only if start.cur == start.first.  

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,令其指向新节点  

        start.cur = start.last - 1;            // 设定start的状态  

        construct(start.cur, t_copy);          // 针对标的元素设值  

    }  

    catch(...)  

    {  

        start.set_node(start.node + 1);  

        start.cur = start.first;  

        deallocate_node(*(start.node - 1));  

        throw;  

    }  

}  

  

// 只有当 finish.cur == finish.first 时才会被调用  

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状态,使指向  

    finish.cur = finish.last - 1;       // 上一个缓冲区的最后一个元素  

    destroy(finish.cur);                // 将该元素析构  

}  

  

// 只有当 start.cur == start.last - 1 时才会被调用  

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状态,使指向  

    start.cur = start.first;         // 下一个缓冲区的第一个元素  

}  

  

  

////////////////////////////////////////////////////////////////////////////////  

// 在指定位置前插入元素  

////////////////////////////////////////////////////////////////////////////////  

//              insert_aux(iterator pos, const value_type& x)  

//                                   |  

//                                   |----------- 判断pos前端元素少还是后端元素少  

//                                   |  

//               -----------------------------------------------  

//         前端少 |                                       后端少 |  

//               |                                             |  

//               ↓                                             |  

//           进行相关操作                                   进行相关操作  

////////////////////////////////////////////////////////////////////////////////  

// 下面以pos前面元素少的情形进行说明为了简化假设操作不会超过一个缓冲区区间  

//  

// 插入前状态  

//           start            pos                                 end  

//             ↓               ↓                                   ↓  

// ---------------------------------------------------------------------  

// |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   | X |  

// ---------------------------------------------------------------------  

//  

// 需要进行操作的区间  

//                需要拷贝的区间  

//                 -------------  

//       start     |           |                                  end  

//         ↓       ↓           ↓                                   ↓  

// ---------------------------------------------------------------------  

// |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   | X |  

// ---------------------------------------------------------------------  

//             ↑   ↑       ↑   ↑  

//        front1   |       |   |  

//                 |       |   |  

//            front2       |   |  

//                         |   |  

//                       pos   |  

//                             |  

//                          pos1  

// 拷贝操作完成后  

//  

//         这是[front2, pos1)  

//             ------------- --------- 这里是给待插入元素预留的空间  

//       start |           | |                                    end  

//         ↓   ↓           ↓ ↓                                     ↓  

// ---------------------------------------------------------------------  

// |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   | X |  

// ---------------------------------------------------------------------  

//         ↑  

//   这里存储的是原来的front()  

//  

////////////////////////////////////////////////////////////////////////////////  

  

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);    // 元素移动  

    }  

    else    // 插入点之后的元素个数比较少  

    {  

        push_back(back());         // 在最尾端加入与最后元素同值的元素  

        iterator back1 = finish;   // 以下标示记号,然后进行元素移动  

        --back1;  

        iterator back2 = back1;  

        --back2;  

        pos = start + index;  

        copy_backward(pos, back2, back1);    // 元素移动  

    }  

    *pos = x_copy;    // 在插入点上设定新值  

    return pos;  

}  

相关文章推荐

STL源码剖析——deque

一、deque的中控器 deque是连续空间(至少逻辑上看来如此),连续线性空间总令我们联想到array或vector。array无法成长,vector虽可成长,却只能向尾端成长,而且其所谓的成长原是...

《STL源码剖析》深入分析序列式容器——deque

欲抑先扬!先来看一下deque的优点:(1)头部插入删除操作,常数时间;(2)vector的假象三部曲“因空间不足a寻觅更大空间;b复制原数据;c释放源空间”在deque是不会发生的。因此也就不需要提...

STL源码剖析之序列容器deque

一、定义 deque是两端都可以插入删除的线性表。 图示: deque与vector的区别: (1)deque两端都可已插入删除,vector只在尾端插入删除; (2)deque没有...

STL源码剖析之Deque容器【2013.11.25】

STL源码剖析之Deque容器【2013.11.25】 deque是说起来和上一篇的List有点像,他是一个双向队列,但是不循环。 (队列:在一个顺序空间内 实现一种 先进后出 的属性) ...
  • xinmuba
  • xinmuba
  • 2013年11月25日 15:42
  • 1223

stl源码剖析之vector,list,deque迭代器分析

一.模型 vector维护的是连续线性空间,当空间大小不足时,另辟一块更大的内存,将之前空间的所有元素移至新空间,并销毁释放原空间。stl中list是一个环状双向链表,它维护的不是连续空间...

STL之deque源码剖析

暑假那会就开始看 STL 源码了,看了不少,空间配置器,vector,list,map 等等,但是都没有总结,现在感觉忘了不少。最近趁上课没事干,把 STL 源码复习复习,今天就看的所谓的双端队列 d...

STL源码剖析---deque

一、deque的中控器       deque是连续空间(至少逻辑上看来如此),连续线性空间总令我们联想到array或vector。array无法成长,vector虽可成长,却只能向尾端成长,而且其...

stl源码剖析 详细学习笔记deque(1)

// //  note.cpp //  笔记 // //  Created by fam on 15/3/12. // // //-------------------------...
  • boydfd
  • boydfd
  • 2015年03月13日 22:39
  • 600

stl源码剖析 详细学习笔记deque(2)

//---------------------------15/3/13----------------------------                 self& operator++() ...
  • boydfd
  • boydfd
  • 2015年03月14日 14:53
  • 515

STL 之 deque 源码剖析

参考侯捷的源码分析,随着理解的深入会加入自己的注解! G++ 2.91.57,cygnus\cygwin-b20\include\g++\stl_deque.h 完整列表 /* * * Cop...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:STL源码剖析---deque
举报原因:
原因补充:

(最多只允许输入30个字)