STL之deque源码剖析

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


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


一: Deque 概述


vector 是我们最常用的容器了,vector 是单向开口的连续线性空间,简单说就是数组。deque 则是一种双向开口的连续线性空间,就是可以在头部和尾部添加或删除元素。

deque 和 vector 的差异:
  1. deque 允许常数时间内对头端进行插入或删除操作。
  2. deque 没有所谓的容量概念,因为它是动态的以分段连续空间组合而成,随时可以增加一段新的空间并链接起来。像 vector 那样 “因旧空间不足而配置重新配置一块更大空间,然后复制元素,再释放旧空间” 这样的事情 deque 是不会发生的。因此,deque 也没有 提供 reserve 方法。(注意:deque 迭代器也存在失效的可能,后面会说)。
相同:
        deque 和 vector 一样,也提供随机访问能力,但其迭代器实现过于复杂(内部有三个指针),所以,除非必要,尽量用 vector 。甚至对 deque 的 排序,为了最高效率,都要先将 deque 复制到 vector,然后排序完毕再还回去(坑)。


二:Deque 的中控器



deque 内部采用 分段式的连续线性空间,整体不是连续的,但每一段确实连续空间。为了给用户造成一种整体就是连续一大片的现象,就需要一个控制层面来管理这些整体不连续的段空间,STL 使用了一个 map,不是 map 容器,map 实际上是一个 T** 类型的指针,当它动态分配好空间之后,就是一个指针数组,数组长度就是我们要分配的缓冲区数目,也就是要分配几段这种连续空间,默认最小为 8 个。数组中的每个指针指向我们使用 alloctor 分配的一片缓冲区,缓冲区用来存放元素内容。如图:


缓冲区用来存放实际元素,每个缓冲区大小默认512字节。

缓冲区大小函数:
inline size_t __deque_buf_size(size_t n, size_t sz)   //__deque_iterator的构造函数模板参数为:template <class T, class Ref, class Ptr, size_t BufSiz>
{
  return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));
}

到此处本来应该分析缓冲区的配置的,但是我们要知道 deque 的 iterator 和普通的容器的 iterator 不一样,剖析 deque 实际上最重要的就是这个迭代器,因为它不像 vector,list 等容器的迭代器,内部仅封装了一个薄薄的指针。deque 的迭代器内部有 4 个指针。下面会分析。

三:Deque 的迭代器


先说下为什么需要 4 个指针,因为我们需要该迭代器做到以下几点,而不是像 vector 的迭代器那样封装 T* ,能够取用元素,前进后退等就足够了:
  1. 它必须能够指出分段连续空间(即缓冲区)在哪里,能进行缓冲区内部元素的增添等操作。
  2. 它必须能够判断自己是否处于缓冲区的边缘,如果是,一旦前进后退就必须跳跃至下一个或上一个缓冲区。
  3. 为了能够跳跃,deque 必须能够随时掌控管控中心。
所以 STL 为 deque 设计了 4 个指针:
  1. cur 指针:cur 指针指向此迭代器所指向缓冲区的 current 元素,用于支持数据操作。
  2. first 指针:first 指针指向所指缓冲区的头,用来控制头部边界
  3. last 指针:last 指针指向所指缓冲区的尾部下一个,实际上已经指向缓冲区之外,符合 [ first, last)。
  4. node 指针:node 指针指向管控中心,当元素到达缓冲区边沿时,元素需要跳到下一缓冲区,这是就要和 node 配合了。
所以我习惯称 deque 的迭代器为一个 ”大迭代器“,不过这个 ”大迭代器“ 的操作核心其实还是 cur,cur 指针真正意义上就相当于我们所用的 vector 的那种迭代器,它表示元素的指针情况,其他三个指针只是为了辅助 cur 指针实现数据结构的功能而存在。如果不是因为底层空间是分段的话,其他几个指针都没有存在的必要了。在分段连续空间中,我们要保证cur 指针的正常前进,就得用其他 3 个指针,前进不了则让 cur 跳跃就行了。

iterator 的图示如下:

iterator 的构造函数:
template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator {
  typedef __deque_iterator<T, T&, T*, BufSiz>             iterator;
  typedef __deque_iterator<T, const T&, const 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;   //T**类型
  ...
}
我们说到元素到缓冲区边界需要跳跃到其他缓冲区,其实是靠这个函数实现的:
 //跳跃缓冲区,可以前进也可以后退
  void set_node(map_pointer new_node) {
    node = new_node;   //node指针指向要跳跃的node
    first = *new_node;   //改变 first
    last = first + difference_type(buffer_size());  //改变last
  }
};
下面将会给出 iterator 支持的常见操作,不过要注意的是,它的任何 operator 重载都是围绕 cur 指针的,例如 operaror++,并不是说迭代器+1就到了下一个结点,其意义实际上是迭代器内部的 cur 指针进行了+1操作,向后移动了 T 类型的举例。 所以可以说 cur 指针是迭代器唯一的身份认证,cur 不一样就说明不是同一个迭代器!

重载 * 和 -> 函数:
reference operator*() const { return *cur; }
pointer operator->() const { return &(operator*()); }
如你所见,这两个函数返回的就是 cur 的内容,所以它们才是迭代器的身份认证,是真正的迭代器,其他指针指示 ”打辅助“ 的。

一些其他函数:
difference_type operator-(const self& x) const {  //迭代器位置之差,就是cur之差,也就是中间缓冲区长度,加上它们分别所在缓冲区实际元素长度
    return difference_type(buffer_size()) * (node - x.node - 1) +   
      (cur - first) + (x.last - x.cur);
  }

  self& operator++() {  //前置++,进行 cur 的++操作,如果等于 last(last 指向缓冲区外),跳到下一个缓冲区
    ++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;
  }

  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;//>0向后跳,<0向前跳,向前跳注意不能直接除bufsize,否则值不足bufsize,计算结果为0
      set_node(node + node_offset);  //切换到正确结点
      cur = first + (offset - node_offset * difference_type(buffer_size()));  //切换正确元素(核心还是要处理 cur 吧)
    }
    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; }   // 呵呵,注意判断的是 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);  // 判断 cur
  }


四:Deque 的数据结构


直接来看它的类吧:
template <class T, class Alloc = alloc, size_t BufSiz = 0> 
class deque {
public:                         // Iterators

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

protected:                      // Internal typedefs
  typedef pointer* map_pointer;
  typedef simple_alloc<value_type, Alloc> data_allocator;
  typedef simple_alloc<pointer, Alloc> map_allocator;

  static size_type initial_map_size() { return 8; }

protected:                      // Data members
  iterator start;
  iterator finish;

  map_pointer map;
  size_type map_size;

public:                         // Basic accessors
  iterator begin() { return start; }
  ...
}
其中包含了迭代器、默认的两个空间配置器(用来配置数据和map),以及一个 start 迭代器和 finish 迭代器:
deque 构造好可能是这样的:

其中 first 迭代器代表了 map 的第一个缓冲区的 cur ,同样还是那句老话,first 迭代器不是结点,也不是指向了第一个缓冲区,它代表了第一个缓冲区的 cur 指针所对应的迭代器,也就是 deque 的第一个元素。同理, finish 代表的是最后一个缓冲区的 cur,这个 cur 符合 STL 左闭右开区间原则,所以实际上指向的元素不属于 deque,所以 finish 是一个实际元素以外的迭代器。那么 deque 的 begin() 函数就应该返回迭代器 start, end() 函数就应该返回迭代器 finish了。

来看下 deque 的构造函数:
deque(long n, const value_type& value)
    : start(), finish(), map(0), map_size(0)
  {
    fill_initialize(n, value);
  }
实际调用的是:
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(*cur, *cur + buffer_size(), value);
    uninitialized_fill(finish.first, finish.cur, value);
  }
}
该函数会调用 create_map_and_nodes() 函数进行创建过程,以及用 uninitialized_fil() 函数取填充值,我们只看前者:
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);  //默认最小8个结点,大于8个,则分配num+2个,因为前后预留一个,翻遍扩充
  map = map_allocator::allocate(map_size);
  //以上培植出一个 "具有map_size个节点的"map

  //以下令nstart和nfinish指向map数组全部结点的中央区段
  //保持在最中央,可使头尾两端扩充能量一样大,每个节点可对应一个缓冲区
  map_pointer nstart = map + (map_size - num_nodes) / 2;  
  map_pointer nfinish = nstart + num_nodes - 1;
    
  map_pointer cur;
  __STL_TRY {
    //为mep内的每个 现用 节点配置缓冲区,注意前后预留的不会配置缓冲区,所以缓冲区加起来就是deque的可用空间
    //可用空间(最后一个可用空间可能留有一些余裕澹?
    for (cur = nstart; cur <= nfinish; ++cur)
      *cur = allocate_node();
  }
  start.set_node(nstart);
  finish.set_node(nfinish);  
  start.cur = start.first;
  finish.cur = finish.first + num_elements % buffer_size();
  //前面说过,如果刚好整除,会多配一个节点
  //此时即令cur指向这多配的一个节点起始处
}

嗯,只要明白了迭代器的实质是 cur 指针,知道了 deque 的构造轮廓,其他函数也没什么难点了,本文就到这里 。其他函数可以参考这篇: STL之deque容器的实现框架。


参考:《STL源码剖析》








 
STL源码剖析——deque的实现原理和使用方法详解 Deque 简介     deque是“double—ended queue”的缩写,和vector一样都是STL的容器,deque 是双端数组,而 vector 是单端的。     deque 在接口上和 vector 非常相似,在许多操作的地方可以直接替换。     deque 可以随机存取元素(支持索引值直接存取,用[]操作符或at()方法,这个等下会详讲)。     deque 头 阅读详情

相关推荐

C++ STL源码剖析之序列式容器deque

通过深入了解deque的实现,我们可以更好地理解其工作原理,并在实际开发中更好地应用和优化deque的使用。在本文中,我们将深入探讨deque的实现细节,包括它的内部数据结构和关键操作的源代码。在实际使用deque时,建议使用C++标准库提供的deque模板类,它封装了上述操作,并提供了更多功能和安全性保证。它首先检查当前活动缓冲区是否为空,如果为空,则将当前活动缓冲区指针指向上一个缓冲区,并释放当前活动缓冲区的内存。它首先检查当前活动缓冲区是否已满,如果满了,则分配一个新的缓冲区,并更新相关指针。

DevForge的博客 110

双端队列(Deque)

deque,即双端队列(double ended queue),是一种可以在两端扩展或收缩的序列化容器。deque是C++ 标准模板库的一部分,想要使用deque,需要在程序中包含头文件deque。规定了deque中可以存放哪种类型的元素。为deque名。

Hacket_Xu的博客 1万+

【STL源码剖析】deque 的使用

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

2301_79201049的博客 1291

C++中deque的用法(超详细,入门必看)

【C++STL】之deque的用法。本文主要讲解了C++STL中的deque的定义及初始化和一些关于deque的常用用法。如果你觉得本文对你有所帮助的话,还望不吝惜您的三连支持一下我哦!

H1727548的博客 3万+

从爱好者到工程师:如何低成本体验RFSoC ZU47DR?性能实测与避坑指南

本文详细介绍了如何低成本体验赛灵思RFSoC ZU47DR芯片,包括二手开发板选购、租赁服务、精简开发环境搭建等实用方案。通过性能实测与避坑指南,帮助爱好者和工程师在有限预算下充分利用这款集成了ARM处理器和FPGA的高性能芯片,降低开发门槛。

weixin_42525005的博客 222

Pi0 项目复现及项目问题解决方案(全网抢先发布~)

Pi0 项目复现及项目问题解决方案(全网抢先发布~)

m0_68167062的博客 2263

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万+

FEniCS学习笔记01:centos7下通过conda安装FEniCSx0.7

2023年版本的Fenicsx0.7,官网推荐使用conda命令安装集成好的Python包,因此我们的安装思路是先安装Anaconda,再按照官网步骤安装Fenics。

huahua_xiao的博客 5058

详解c++STL—容器deque

详解c++STL库中的容器deque—双端数组

怀秋秋意的博客 3825

双臂复合机器人眼在手外标定实战:从原理到D435标定流程详解

本文详细解析了双臂复合机器人中眼在手外标定的核心原理与实战流程。通过阐述坐标系转换与AX=XB方程,重点介绍了使用Intel RealSense D435相机进行标定的完整步骤,包括环境搭建、数据采集、计算与验证,并提供了关键的避坑指南,帮助工程师实现相机与机械臂基座间的精确坐标对齐。

weixin_29100927的博客 461

3分钟搞定!QQ音乐歌单导出Excel保姆级教程(含歌单ID获取技巧)

本文提供了一份详细的QQ音乐歌单导出Excel保姆级教程,帮助用户轻松备份和管理个人音乐收藏。教程核心在于获取歌单ID,并利用浏览器开发者工具执行脚本提取数据,最后通过Excel导入功能快速生成结构化表格。整个过程无需编程基础,3分钟即可搞定,是个人数据管理的实用技巧。

weixin_29008691的博客 1414

deque

deque,即双端队列(double-ended queue),是一种具有队列和栈的性质的数据结构。它允许你在队列的两端进行元素的插入和删除操作。在C++的STL(Standard Template Library)中,deque是一个模板类,可以存储任何类型的数据。

weixin_40026739的博客 1092

MATLAB 基于 Baker 映射和 Logistic 混沌序列的图像加解密实现

图像加密是信息安全领域的重要研究方向,在数字版权保护、隐私保护等领域有着广泛应用。本文将介绍基于 MATLAB 的 Baker 映射和 Logistic 混沌序列的图像加解密算法,该算法利用混沌系统的初值敏感性和伪随机性,能够有效地对图像进行加密和解密。基于 Baker 映射和 Logistic 混沌序列的图像加解密算法是一种有效的方法,可以应用于数字版权保护、隐私保护等领域。MATLAB 提供了强大的工具和函数,可以方便地实现该算法。

走向CTO的路上... 937

C++ STL deque容器源码剖析

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

Friday____的博客 639

HQChart实战教程49-点击修改K线颜色及背景色

HQChart实战教程49-点击修改K线颜色及背景色需求效果图步骤1. 注册点击监听事件2. 修改K颜色添加一个自定义颜色的K线klineoption清空所有自定义颜色的K线option交流QQ群: 950092318HQChart代码地址完整例子 需求 对点击的K线修改颜色。 效果图 步骤 1. 注册点击监听事件 事件ID JSCHART_EVENT_ID.ON_CLICK_CHART_PAINT, 注册监听事件见教程 HQChart使用教程5- K线图控件操作函数说明 this.Create=func

小银 2911

基于转录逆转的药物重定向 GPS 模型

GPS是一个基于分子结构预测基因表达扰动的开源平台,由三个模块组成:RCL(在LINCS扰动数据上训练抗噪MLP)、GPS4Drugs(预测新化合物的基因表达谱并进行逆转评分)、MolSearch(基于MCTS的分子优化)。平台使用Morgan指纹和Gene Ontology注释作为特征输入,将基因表达扰动离散为三分类标签。训练数据来自LINCS Phase I的18,746个化合物和978个landmark基因,支持四细胞系独立训练,可用于药物重定向与化合物筛选。

听雨草堂 84

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

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

燃于AC之乐的博客 1319

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

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

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

STL deque源码剖析

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

xuwqiang1994的博客 396

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

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

Hackbuteer1的专栏 1万+

STL—deque使用及源码剖析

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

tkzky001的博客 490
上一篇: deque容器的实现框架
下一篇: 《深度探索C++对象模型》读书笔记第一章:关于对象
FreeeLinux
博客等级 码龄11年 421粉丝 356原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值