STL源码剖析---deque

STL源码剖析——序列容器之deque 前言 阅读详情

deque的概述

deque是一种双向开口的连续线性空间,允许我们在头尾两端操作。所以我们需要保证deque可以在常数时间内对头和尾元素进行插入或者删除。 Deque还有一个明显的与Vector不同的特点,就是它没有capacity的概念,它是动态地用分段连续的空间组合起来的,随时可以增加一段新的空间并连接起来,而为了隐藏deque的这些底层细节(分段连续的空间组成---需要一个中央管理器来管理这些空间),deque设计者必须让用户感觉在使用一个整体连续的对象,并且提供了随机存取的接口,这样一来,就需要复杂的迭代器结构。

一、deque的中控器
      deque是连续空间(至少逻辑上看来如此),连续线性空间总令我们联想到array或vector。array无法成长,vector虽可成长,却只能向尾端成长,而且其所谓的成长原是个假象,事实上是(1)另觅更大空间;(2)将原数据复制过去;(3)释放原空间三部曲。如果不是vector每次配置新空间时都有留下一些余裕,其成长假象所带来的代价将是相当高昂。
      deque系由一段一段的定量连续空间构成。一旦有必要在deque的前端或尾端增加新空间,便配置一段定量连续空间,串接在整个deque的头端或尾端。deque的最大任务,便是在这些分段的定量连续空间上,维护其整体连续的假象,并提供随机存取的借口。避开了“重新配置、复制、释放”的轮回,代价则是复杂的迭代器架构。
      受到分段连续线性空间的字面影响,我们可能以为deque的实现复杂度和vector相比虽不中亦不远矣,其实不然。主要因为,既是分段连续线性空间,就必须有中央控制,而为了维持整体连续的假象,数据结构的设计及迭代器前进后退等操作都颇为繁琐。deque的实现代码分量远比vector或list都多得多。
      deque采用一块所谓的map(注意,不是STL的map容器)作为主控。这里所谓map是一小块连续空间,其中每个元素(此处称为一个节点,node)都是指针,指向另一段(较大的)连续线性空间,称为缓冲区。缓冲区才是deque的储存空间主体。SGI STL 允许我们指定缓冲区大小,默认值0表示将使用512 bytes 缓冲区。

Template<class T, class Alloc=alloc, size_t BufSize=0 >
Class deque
{
Public:
Typedef T value_type;
Typedef value_type* pointer;
//其他typedef….
Protected:
Typedef pointer* map_pointer;    //指向元素指针类型的指针(元素为指针类型的数组)
Protected:
Map_pointer map;                     // T** map
Size_type map_size;
};

 clip_image002

二、deque的迭代器
      让我们思考一下,deque的迭代器应该具备什么结构,首先,它必须能够指出分段连续空间(亦即缓冲区)在哪里,其次它必须能够判断自己是否已经处于其所在缓冲区的边缘,如果是,一旦前进或后退就必须跳跃至下一个或上一个缓冲区。为了能够正确跳跃,deque必须随时掌握管控中心(map)。所以在迭代器中需要定义:当前元素的指针,当前元素所在缓冲区的起始指针,当前元素所在缓冲区的尾指针,指向map中指向所在缓区地址的指针。
在进行迭代器的移动时,需要考虑跨缓冲区的情况。
重载前加(减),在实现后加(减)时,调用重载的前加(减)。
重载+=,实现+时,直接调用+=,实现-=时,调用+=负数,实现-时,调用-=.
//当需要实现新的功能时,最好使用已经重载好的操作,即方便有安全。。。。
另外,deque在效率上来说是不够vector好的,因此有时候在对deque进行sort的时候,需要先将元素移到vector再进行sort,然后移回来。

构造函数:根据缓冲区设置大小和元素个数,决定map的大小;给map分配空间,根据缓冲区的个数,分配缓冲区,默认指定一个缓冲区;
 设置start和finish迭代器,满足左闭右开的原则。
 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,删除原来空间)、插入后元素是前面元素向前移动还是后面元素向后面移动(谁小移动谁)。而在删除元素的时候,考虑是将前面元素后移覆盖需要移除元素的地方还是后面元素前移覆盖(谁小移动谁)。移动完以后要析构冗余的元素,释放冗余的缓存区。 

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

https://i-blog.csdnimg.cn/blog_migrate/0a96ae311bdbd023f7e26010bf842011.jpeg

deque的数据结构

deque除了维护一个先前说的指向map的指针外,也维护start,finish两个迭代器,分别指向第一缓冲的第一元素和最后缓冲区的最后一个元素(的下一位置)。此外,它必须记住目前的map的大小。因为一旦map所提供的节点不足,就必须重新配置更大的一块map。

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; }  
<pre name="code" class="cpp">    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是“double—ended queue”的缩写,和vector一样都是STL的容器,deque 是双端数组,而 vector 是单端的。     deque 在接口上和 vector 非常相似,在许多操作的地方可以直接替换。     deque 可以随机存取元素(支持索引值直接存取,用[]操作符或at()方法,这个等下会详讲)。     deque 头 阅读详情

相关推荐

【STL源码剖析】deque 的使用

deque是有下标顺序容器,它允许在其首尾两段快速插入及删除。另外,在任一端插入或删除不会非法化指向其余元素的指针或引用。是一块连续的空间(至少逻辑看来如此),连续空间我们可能会想到(数组)或者。无法成长,虽然可以成长但是只有尾端成长,而且扩容(成长)只是假象,实际上是:另寻更大的空间、将原资料拷贝过去、释放原空间。这样的话成长所带来的代价是相当高的。的想象结构:就是相同的连续空间拼接而成而巧妙的避开了的缺点,

2301_79201049的博客 1291

C++STL:顺序容器之deque

deque 是 double-ended queue 的缩写,又称双端队列容器。moredeque 容器也擅长在序列尾部添加或删除元素(时间复杂度为O(1)),而不擅长在序列中间添加或删除元素。deque 容器也可以根据需要修改自身的容量和大小。和 vector 不同的是,deque 还擅长在序列头部添加或删除元素,所耗费的时间复杂度也为常数阶O(1)。并且更重要的一点是,deque 容器中存储元素并不能保证所有元素都存储到连续的内存空间中。

crossoverpptx的博客 1520

DC-DC 转换器中的压电谐振器:当前状态和限制

在功率转换器应用中,居里温度较低的谐振器的 k 2和 Q M显着降低会导致效率降低,需要仔细的热处理。由于使用 PR 的功率转换器在不同的条件下运行,包括温度范围、电压偏置和功率电平,因此不可避免地会出现非线性效应,必须妥善解决这一问题,以免影响转换器的性能。等效电路模型(Butterworth Van-Dyke 或 BVD 模型)将压电谐振器在其机械谐振附近的电响应转换为一个简单电路,该电路由与由电极形成的输入电容 C 0并联的串联 RLC 动分支组成,见图图 1 还显示了阻抗与频率的关系。

2301_79716471的博客 1299

深入理解deque

deque是一种双向开口的连续线性空间,所谓双向开口,意思是可以在头尾两端分别做元素的插入和删除操作,如图所示deque允许常数时间内对起头端进行元素的插入和删除操作,deque没有所谓容量观念,因为它是动态地以分段连续空间组合而成,随时可以增加一段新的空间并链接起来,因此,deque没有必要提供所谓的空间保留功能虽然deque也提高RamdonAccessIterator,但它的迭代器并不是普通指针,这影响了各个运算层次,因此,除非必要,我们应尽可能选择使用vector而非deque。...

guicaifjz的博客 850

芯片详解——AD7606

AD7606详解

weixin_45661757的博客 5023

基于STM32 HAL库的L298N四驱电机PWM调速与方向控制实战

本文详细介绍了基于STM32 HAL库驱动L298N电机控制板实现四驱小车PWM调速与方向控制的实战方法。涵盖硬件连接、GPIO与定时器配置、PWM生成、方向控制逻辑及电源管理等核心内容,并提供代码优化与常见问题解决方案,帮助开发者快速实现高效稳定的电机控制。

jump7的博客 222

deque用法深度解析,一篇文章弄懂deque容器各种操作

deque deque容器 std::deque C++ deque的用法与示例 deque用法详解 C++deque介绍 deque push_front deque push_back deque pop_front deque pop_back deque push pop deque insert deque erase deque emplace deque size deque empty deque front deque back deque assign deque clear swap

在下马农的碎碎念 2万+

Linux环境下使用线程方式操作UART读写功能

本文介绍Linux环境下使用线程方式操作UART的方法,实现了串口打开,关闭,发送数据,接收数据功能,还编写测试代码,验证该功能。

mftang的博客 2080

【C++】deque的实现原理简单介绍

【C++】deque的实现原理简单介绍

一点一点变好 4374

SAP系统中PP模块全配置文档

配置路径IMG>SAP NetWeaver>常规设置>维护日历>工厂日历事务代码SCAL要求传输工厂代码描述日历代码日历描述起始日期星期一星期二星期三星期四星期五星期六星期日有效开始日期有效结束日期1000南微医学工厂MT南微医学工厂日历√√√√√√√201820502.4定义工厂配置路径IMG>生产>物料清单>常规数据>定义BOM状态事务代码OS23要求传输配置路径IMG>生产>主数据>资源>常规数据>标准值>定义参数。

yanzibing99的博客 1895

YOLOv8改进策略【卷积层】| CVPR-2023 部分卷积 PConv 轻量化卷积,降低内存占用

本文记录的是利用优化的目标检测方法研究。深度可分离卷积可以减少FLOPs,但会导致更高的内存访问,引起延迟并减慢整体计算。部分卷积利用逐点卷积处理通道冗余,减少模型计算量和内存访问量。Run, Don’t Walk: Chasing Higher FLOPS for Faster Neural Networks及其改进的实现代码如下: 四、创新模块 4.1 改进点⭐ 模块改进方法:直接加入(第五节讲解添加步骤)。模块加入如下:模块改进方法:基于的(第五节讲解添加步骤)。第二种改进方法是对中的进行改进,并将

Limiiiing的博客 1018

C++ STL deque容器源码剖析

块状链表是一个集合了分块和链表的优秀数据结构。其做法就是维护一个链表,链表中的每个单元都包含一段数组,以及这个数组中的数据个数。普通的链表每次插入元素的时候都要向操作系统申请一个数量少的小空间,操作系统为了申请这块空间所花的时间和内存维护的成本是一样多的,此操作的性价比非常低,并且频繁的释放小空间的操作容易形成过多的内存碎片。

Friday____的博客 639

FPGA JTAG接口设计全解析

JTAG是FPGA开发的核心接口,主要用于代码下载和在线调试。14-pin设计中包含TCK、TMS、TDI、TDO四个关键信号,采用信号-地布局增强抗干扰能力,TCK建议串联电阻。10-pin设计需注意转接适配,并推荐使用RCLAMP0524P等低电容TVS二极管进行ESD防护。两种接口设计都强调信号完整性和可靠性,建议PCB布局时保持JTAG走线短且预留调整空间。

在读研究生,FPGA电路设计与功能开发。 2192

STL源码剖析——deque

1 template <class T, class Alloc = alloc> class vector { public: typedef T value_type; typedef value_type* pointer; typedef value_type* iterator; typedef value_type& reference; typedef size_t size_type; ty

I_ren的博客 291

PCL点云库入门(第6讲)——PCL库中Eigen数学工具库的基本使用(持续更新)

Eigen库是一个高性能的C++模板库,专注于线性代数、矩阵和向量运算,以及相关的数值分析和算法。在Eigen库中,所有的矩阵和向量均被视为矩阵模板类的实例。向量可以被看作是特殊形式的矩阵,具体表现为只包含1行或1列。

qq_36812406的博客 1755

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

深入解剖STL deque:从源码剖析到容器适配器实现

✨本文深入剖析STL deque的底层实现原理,详细讲解其三层架构设计:中控器(map)、缓冲区(buffer)和复杂迭代器。通过源码分析揭示了deque如何实现头尾O(1)时间复杂度的插入删除操作,以及维护"整体连续"假象的技术细节。进一步探讨了基于deque的容器适配器实现,包括queue和priority_queue的设计原理与性能特点。文章最后提供各容器选型建议,帮助读者在实际开发中做出合理选择。掌握这些知识对于深入理解STL设计哲学和编写高效C++代码具有重要意义。

燃于AC之乐的博客 1319

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

STL之deque源码剖析

暑假那会就开始看 STL 源码了,看了不少,空间配置器,vector,list,map 等等,但是都没有总结,现在感觉忘了不少。最近趁上课没事干,把 STL 源码复习复习,今天就看的所谓的双端队列 deque。 一: Deque 概述 vector 是我们最常用的容器了,vector 是单向开口的连续线性空间,简单说就是数组。deque 则是一种双向开口的连续线性空间,就是可以

FreeeLinux's blog 877

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

STL deque源码剖析

deque(double-ended queue)是一种双向开口的序列容器,可以在头部和尾部进行push或pop操作,与vector不同,deque不是真正的连续线性空间,它是由分段连续空间动态组合而成。 map是一个二重指针,指向一个指针数组,数组中每个元素都为指针,指向各个相同大小的缓冲区,容器deque中的元素就放在这些缓冲区中,当map中的缓冲区满载后,就会配置一个新的map指向...

xuwqiang1994的博客 396

STL源码剖析学习-深度探索Deque

暂null

La745739773的博客 270

stl源码剖析_stl源码剖析(九)deque

vector是单向开口的连续线性空间,deque则是一种双向开口的连续线性空间。如图1deque与vector的差异:1.deque允许于参数时间内对起头端进行元素的插入或移除操作。2.deque没有所谓容量(capacity)概念,因为deque是动态地以分段连续空间组合而成。3.deque也提供了Ramdon Access Iterator,但它的迭代器并不是普通的指针,比vector复杂多些...

weixin_39746794的博客 291

STL源码剖析——deque的实现

deque简介deque是一个双向开口的容器,可在头尾两端插入和删除元素,deque由动态的连续空间组合而成,因为迭代器的良好设计,提供了随机访问,造成一种deque为连续空间的假象deque的数据结构deque有一个二级指针map,map指向一小块空间,其中的每个元素都是指针,指向一段连续线性空间,称为缓冲区,缓冲区为deque存储的主体,其中存放元素tempalte <class T, clas

ProgrammingLearner的博客 672

STL—deque使用及源码剖析

文章目录deque概述deque的使用deque源码剖析控制中心迭代器insert方法 deque概述 deque容器为一个给定类型的元素进行线性处理,像向量一样,它能够快速地随机访问任一个元素,并且能够高效地插入和删除容器的尾部元素。但它又与vector不同,deque支持高效插入和删除容器的头部元素,因此也叫做双端队列。 deque容器可以在双端插入和删除,其底层是分段连续的,对于使用者来说造成了一种连续的假象。 deque的使用 deque类常用的函数有: (1) 构造函数 deque():

tkzky001的博客 490
上一篇: STL源码剖析—list
下一篇: STL源码剖析---stack,queue
天天向上zb
博客等级 码龄16年 34粉丝 43原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值