STL源码剖析—list

STL源码剖析——序列容器之list 前言 在SGI ST 阅读详情

相较于vector的连续线性空间,list就显得复杂许多,它的好处是每次插入或删除一个元素,就配置或释放一个元素空间。因此,list对于空间的运用有绝对的精准,一点也不浪费。而且,对于任何位置的元素插入或元素移除,list永远是常数时间。

list不仅是一个双向链表,而且还是一个环状双向链表。另外,还有一个重要性质,插入操作和接合操作都不会造成原有的list迭代器失效,这在vector是不成立的。因为vector的插入操作可能造成记忆体重新配置,导致原有的迭代器全部失效。甚至list的元素删除操作(erase),也只有“指向被删除元素”的那个迭代器失效,其他迭代器不受任何影响。

以下是list的节点的结构:

  • ///////////////////////////////////////////////////////////////////////////////  
  • // list结点, 提供双向访问能力  
  • ////////////////////////////////////////////////////////////////////////////////  
  • //  --------           --------           --------           --------  
  • //  | next |---------->| next |---------->| next |---------->| next |  
  • //  --------           --------           --------           --------  
  • //  | prev |<----------| prev |<----------| prev |<----------| prev |  
  • //  --------           --------           --------           --------  
  • //  | data |           | data |           | data |           | data |  
  • //  --------           --------           --------           --------  
  • ////////////////////////////////////////////////////////////////////////////////  

    template <class T>  
    struct __list_node  
    {  
        typedef void* void_pointer;  
        void_pointer next;  
        void_pointer prev;  
        T data;  
    };  

    已下是迭代器数据结构设计以及list的源码剖析

    template<class T, class Ref, class Ptr>  
    struct __list_iterator  
    {  
        typedef __list_iterator<T, T&, T*>             iterator;   // STL标准强制要求  
        typedef __list_iterator<T, Ref, Ptr>           self;  
      
        typedef bidirectional_iterator_tag iterator_category;  
        typedef T value_type;  
        typedef Ptr pointer;  
        typedef Ref reference;  
        typedef __list_node<T>* link_type;  
        typedef size_t size_type;  
        typedef ptrdiff_t difference_type;  
      
        link_type node;   //迭代器内部当然要有一个普通指针,指向list的节点  
      
        __list_iterator(link_type x) : node(x) {}  
        __list_iterator() {}  
        __list_iterator(const iterator& x) : node(x.node) {}  
      
        // 在STL算法中需要迭代器提供支持  
        bool operator==(const self& x) const { return node == x.node; }  
        bool operator!=(const self& x) const { return node != x.node; }  
      
        // 以下对迭代器取值(dereference),取的是节点的数据值  
        reference operator*() const { return (*node).data; }  
      
        // 以下是迭代器的成员存取运算子的标准做法  
        pointer operator->() const { return &(operator*()); }  
      
        // 前缀自加,对迭代器累加1,就是前进一个节点  
        self& operator++()  
        {  
            node = (link_type)((*node).next);  
            return *this;  
        }  
      
        // 后缀自加, 需要先产生自身的一个副本, 然会再对自身操作, 最后返回副本  
        self operator++(int)  
        {  
            self tmp = *this;  
            ++*this;  
            return tmp;  
        }  
      
        // 前缀自减  
        self& operator--()  
        {  
            node = (link_type)((*node).prev);  
            return *this;  
        }  
      
        self operator--(int)  
        {  
            self tmp = *this;  
            --*this;  
            return tmp;  
        }  
    };  
  • ////////////////////////////////////////////////////////////////////////////////  
  • // list不仅是个双向链表, 而且还是一个环状双向链表  
  • ////////////////////////////////////////////////////////////////////////////////  
  • //       end()              头结点             begin()  
  • //         ↓                  ↓                  ↓  
  • //      --------           --------           --------           --------  
  • // ---->| next |---------->| next |---------->| next |---------->| next |------  
  • // |    --------           --------           --------           --------     |  
  • // |  --| prev |<----------| prev |<----------| prev |<----------| prev |<--| |  
  • // |  | --------           --------           --------           --------   | |  
  • // |  | | data |           | data |           | data |           | data |   | |  
  • // |  | --------           --------           --------           --------   | |  
  • // |  |                                                                     | |  
  • // |  | --------           --------           --------           --------   | |  
  • // ---|-| next |<----------| next |<----------| next |<----------| next |<--|--  
  • //    | --------           --------           --------           --------   |  
  • //    ->| prev |---------->| prev |---------->| prev |---------->| prev |----  
  • //      --------           --------           --------           --------  
  • //      | data |           | data |           | data |           | data |  
  • //      --------           --------           --------           --------  
  • ////////////////////////////////////////////////////////////////////////////////  
    list的数据结构 

    // 默认allocator为alloc, 其具体使用版本请参照<stl_alloc.h>  

    template <class T, class Alloc = alloc>  
    class list  
    {  
    protected:  
        typedef void* void_pointer;  
        typedef __list_node<T> list_node;  
      
        // 专属之空间配置器,每次配置一个节点大小  
        typedef simple_alloc<list_node, Alloc> list_node_allocator;  
      
    public:  
        typedef T value_type;  
        typedef value_type* pointer;  
        typedef value_type& reference;  
        typedef list_node* link_type;  
        typedef size_t size_type;  
        typedef ptrdiff_t difference_type;  
      
        typedef __list_iterator<T, T&, T*>             iterator;  
      
    protected:  
        link_type node ;     // 只要一个指针,便可表示整个环状双向链表  
        // 分配一个新结点, 注意这里并不进行构造,  
        // 构造交给全局的construct, 见<stl_stl_uninitialized.h>  
        link_type get_node() { return list_node_allocator::allocate(); }  
      
        // 释放指定结点, 不进行析构, 析构交给全局的destroy  
        void put_node(link_type p) { list_node_allocator::deallocate(p); }  
      
        // 产生(配置并构造)一个节点, 首先分配内存, 然后进行构造  
        // 注: commit or rollback  
        link_type create_node(const T& x)  
        {  
            link_type p = get_node();  
            construct(&p->data, x);  
            return p;  
        }  
      
        // 析构结点元素, 并释放内存  
        void destroy_node(link_type p)  
        {  
            destroy(&p->data);  
            put_node(p);  
        }  
      
    protected:  
        // 用于空链表的建立  
        void empty_initialize()  
        {  
            node = get_node();   // 配置一个节点空间,令node指向它  
            node->next = node;   // 令node头尾都指向自己,不设元素值  
            node->prev = node;  
        }  
      
      // 创建值为value共n个结点的链表  
      // 注: commit or rollback  
        void fill_initialize(size_type n, const T& value)  
        {  
            empty_initialize();  
            __STL_TRY  
            {  
                // 此处插入操作时间复杂度O(1)  
                insert(begin(), n, value);  
            }  
            __STL_UNWIND(clear(); put_node(node));  
        }  
          
      
    public:  
        list() { empty_initialize(); }  
      
        iterator begin() { return (link_type)((*node).next); }  
      
        // 链表成环, 当指所以头节点也就是end  
        iterator end() { return node; }  
      
        // 头结点指向自身说明链表中无元素  
        bool empty() const { return node->next == node; }  
      
        // 使用全局函数distance()进行计算, 时间复杂度O(n)  
        size_type size() const  
        {  
            size_type result = 0;  
            distance(begin(), end(), result);  
            return result;  
        }  
      
        size_type max_size() const { return size_type(-1); }  
        reference front() { return *begin(); }  
        reference back() { return *(--end()); }  
  • ////////////////////////////////////////////////////////////////////////////////  
  •     // 在指定位置插入元素  
  •     ////////////////////////////////////////////////////////////////////////////////  
  •     //       insert(iterator position, const T& x)  
  •     //                       ↓  
  •     //                 create_node(x)  
  •     //                 p = get_node();-------->list_node_allocator::allocate();  
  •     //                 construct(&p->data, x);  
  •     //                       ↓  
  •     //            tmp->next = position.node;  
  •     //            tmp->prev = position.node->prev;  
  •     //            (link_type(position.node->prev))->next = tmp;  
  •     //            position.node->prev = tmp;  
  •     ////////////////////////////////////////////////////////////////////////////////   在迭代器position所指位置插入一个节点,内容为x

    iterator insert(iterator position, const T& x)  
        {  
            link_type tmp = create_node(x);   // 产生一个节点  
            // 调整双向指针,使tmp插入进去  
            tmp->next = position.node;  
            tmp->prev = position.node->prev;  
            (link_type(position.node->prev))->next = tmp;  
            position.node->prev = tmp;  
            return tmp;  
        }  
     // 指定位置插入n个值为x的元素, 详细解析见实现部分  
      void insert(iterator pos, size_type n, const T& x);  
      void insert(iterator pos, int n, const T& x)  
      {  
          insert(pos, (size_type)n, x);  
      }  
      void insert(iterator pos, long n, const T& x)  
      {  
          insert(pos, (size_type)n, x);  
      } 

    // 在链表前端插入结点  
      void push_front(const T& x) { insert(begin(), x); }  
      // 在链表最后插入结点  
      void push_back(const T& x) { insert(end(), x); }  
    // 移除迭代器position所指节点  
      iterator erase(iterator position)  
      {  
          link_type next_node = link_type(position.node->next);  
          link_type prev_node = link_type(position.node->prev);  
          prev_node->next = next_node;  
          next_node->prev = prev_node;  
          destroy_node(position.node);  
          return iterator(next_node);  
      }  
    / 擦除一个区间的结点, 详细解析见实现部分  
      iterator erase(iterator first, iterator last);  
      
      void resize(size_type new_size, const T& x);  
      void resize(size_type new_size) { resize(new_size, T()); }  
      void clear();  
    // 删除链表第一个结点  
      void pop_front() { erase(begin()); }  
      // 删除链表最后一个结点  
      void pop_back()  
      {  
          iterator tmp = end();  
          erase(--tmp);  
      }  
      
      list(size_type n, const T& value) { fill_initialize(n, value); }  
      list(int n, const T& value) { fill_initialize(n, value); }  
      list(long n, const T& value) { fill_initialize(n, value); }  
      
      ~list()  
      {  
        // 释放所有结点  // 使用全局函数distance()进行计算, 时间复杂度O(n)  
      size_type size() const  
      {  
        size_type result = 0;  
        distance(begin(), end(), result);  
        return result;  
      }  
      clear();  
      // 释放头结点  
      put_node(node);  
      }  
      
      list<T, Alloc>& operator=(const list<T, Alloc>& x);  
      
    protected:  
      
        ////////////////////////////////////////////////////////////////////////////////  
        // 将[first, last)内的所有元素移动到position之前  
        // 如果last == position, 则相当于链表不变化, 不进行操作  
        ////////////////////////////////////////////////////////////////////////////////  
        // 初始状态  
        //                   first                             last  
        //                     ↓                                 ↓  
        //      --------   --------   --------     --------   --------   --------  
        //      | next |-->| next |-->| next |     | next |-->| next |-->| next |  
        //  ... --------   --------   -------- ... --------   --------   -------- ...  
        //      | prev |<--| prev |<--| prev |     | prev |<--| prev |<--| prev |  
        //      --------   --------   --------     --------   --------   --------  
        //  
        //                           position  
        //                               ↓  
        //      --------   --------   --------   --------   --------   --------  
        //      | next |-->| next |-->| next |-->| next |-->| next |-->| next |  
        //  ... --------   --------   --------   --------   --------   -------- ...  
        //      | prev |<--| prev |<--| prev |<--| prev |<--| prev |<--| prev |  
        //      --------   --------   --------   --------   --------   --------  
        //  
        // 操作完成后状态  
        //                           first  
        //                             |  
        //               --------------|--------------------------------------  
        //               | ------------|------------------------------------ |   last  
        //               | |           ↓                                   | |     ↓  
        //      -------- | |        --------   --------     --------       | |  --------   --------  
        //      | next |-- |  ----->| next |-->| next |     | next |-----  | -->| next |-->| next |  
        //  ... --------   |  |     --------   -------- ... --------    |  |    --------   -------- ...  
        //      | prev |<---  |  ---| prev |<--| prev |     | prev |<-- |  -----| prev |<--| prev |  
        //      --------      |  |  --------   --------     --------  | |       --------   --------  
        //                    |  |                                    | |  
        //                    |  ------                               | |  
        //                    ------- |  ------------------------------ |  
        //                          | |  |                              |  
        //                          | |  |  -----------------------------  
        //                          | |  |  |  
        //                          | |  |  |  position  
        //                          | |  |  |     ↓  
        //      --------   -------- | |  |  |  --------   --------   --------   --------  
        //      | next |-->| next |-- |  |  -->| next |-->| next |-->| next |-->| next |  
        //  ... --------   --------   |  |     --------   --------   --------   -------- ...  
        //      | prev |<--| prev |<---  ------| prev |<--| prev |<--| prev |<--| prev |  
        //      --------   --------            --------   --------   --------   --------  
        //////////////////////////////////////////////////////////////////////////////// 
    将[first,last)内的所有元素移动到position之前
     void transfer(iterator position, iterator first, iterator last)  
        {  
            if (position != last)   // 如果last == position, 则相当于链表不变化, 不进行操作  
            {  
                (*(link_type((*last.node).prev))).next = position.node;    //1
                (*(link_type((*first.node).prev))).next = last.node;       //2
                (*(link_type((*position.node).prev))).next = first.node;   //3
                link_type tmp = link_type((*position.node).prev);        //4
                (*position.node).prev = (*last.node).prev;        //5
                (*last.node).prev = (*first.node).prev;      //6
                (*first.node).prev = tmp;      //7
            }  
        }  


    公共接口 list<T>::splice的许多版本
    public
    // 将链表x移动到position所指位置之前  
        void splice(iterator position, list& x)  
        {  
            if (!x.empty())  
                transfer(position, x.begin(), x.end());  
        }  
      
        // 将链表中i指向的内容移动到position之前  
        void splice(iterator position, list&, iterator i)  
        {  
            iterator j = i;  
            ++j;  
            if (position == i || position == j) return;  
            transfer(position, i, j);  
        }  
      
        // 将[first, last}元素移动到position之前  
        void splice(iterator position, list&, iterator first, iterator last)  
        {  
            if (first != last)  
                transfer(position, first, last);  
        }  
      
        void remove(const T& value);  
        void unique();  
        void merge(list& x);  
        void reverse();  
        void sort();  
      
    };  
      
    // 销毁所有结点, 将链表置空  
    template <class T, class Alloc>  
    void list<T, Alloc>::clear()  
    {  
      link_type cur = (link_type) node->next;  
      while (cur != node)  
      {  
        link_type tmp = cur;  
        cur = (link_type) cur->next;  
        destroy_node(tmp);  
      }  
      // 恢复node原始状态  
      node->next = node;  
      node->prev = node;  
    }  
      
    // 链表赋值操作  
    // 如果当前容器元素少于x容器, 则析构多余元素,  
    // 否则将调用insert插入x中剩余的元素  
    template <class T, class Alloc>  
    list<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& x)  
    {  
      if (this != &x)  
      {  
        iterator first1 = begin();  
        iterator last1 = end();  
        const_iterator first2 = x.begin();  
        const_iterator last2 = x.end();  
        while (first1 != last1 && first2 != last2) *first1++ = *first2++;  
        if (first2 == last2)  
          erase(first1, last1);  
        else  
          insert(last1, first2, last2);  
      }  
      return *this;  
    }  
      
      
    // 移除容器内所有的相邻的重复结点  
    // 时间复杂度O(n)  
    // 用户自定义数据类型需要提供operator ==()重载  
    template <class T, class Alloc>  
    void list<T, Alloc>::unique()  
    {  
      iterator first = begin();  
      iterator last = end();  
      if (first == last) return;  
      iterator next = first;  
      while (++next != last)  
      {  
        if (*first == *next)  
          erase(next);  
        else  
          first = next;  
        next = first;  
      }  
    }  
      
    // 假设当前容器和x都已序, 保证两容器合并后仍然有序  
    template <class T, class Alloc>  
    void list<T, Alloc>::merge(list<T, Alloc>& x)  
    {  
      iterator first1 = begin();  
      iterator last1 = end();  
      iterator first2 = x.begin();  
      iterator last2 = x.end();  
      
      // 注意:前提是,两个lists都已经递增排序  
      while (first1 != last1 && first2 != last2)  
        if (*first2 < *first1)  
        {  
          iterator next = first2;  
          transfer(first1, first2, ++next);  
          first2 = next;  
        }  
        else  
          ++first1;  
      if (first2 != last2)  
          transfer(last1, first2, last2);  

C++深入学习:STL源码剖析 (3) 从源码深入剖析list C++深入学习:STL源码剖析 (3) 从源码深入剖析list vector和list是最常用的容器,vector是连续的线性空间,list则是非连续的用指针串联起的空间。因此list对于空间的利用是非常充分的,对于任意位置的插入删除操作,list是常数时间完成。 list不仅是双向链表,而且是环形双向链表,因此只需要一个指针便可以实现对整个list的迭代器的标记。为了符合STL的前闭后开的区间要求,list实现时将该指针节点指向一个置于尾端的空白节点,则该节点的前面是尾结点,该节点的后面是头结点,根据此 阅读详情

相关推荐

STL源码剖析——list容器的排序算法sort()

由于STL本身的排序算法sort接受的输入迭代器是随机访问迭代器,但是双向list链表容器的访问方式是双向迭代器,因此,不能使用STL本身的排序算法sort,必须自己定义属于自己访问的排序算法。我们从源码的剖析中,可以看到该排序算法思想类似于归并排序。

关注校招求职,微信号:job_campus 9381

c++ distance unique

函数distance()用来处理两个迭代器之间的距离 Dist distance(pos1,pos2); 传回来的是两个迭代器之间的距离 两个迭代器必须指向同个容器 对于random access迭代器,此函数仅仅只是传回pos2-pos1,复杂度为常数级别; 对于其他迭代器类型,distance()会不断递增pos1,直到抵达pos2为止,然后传回递增次数,也就是说其他类型的迭代器,d...

KEMNHAN的博客 688

标准库list源码

学习STL源码的好助手,是一个非常简化版的SLT list源码,可以让你理解stl的本质

C++中计算迭代器之间的距离 distance

C++中计算迭代器之间的距离 distance

YMWM_的博客 4428

Ubuntu22.04 上ROS1 Noetic的安装与常见问题解决

本文详细介绍了在Ubuntu 22.04系统上安装ROS1 Noetic的两种主要方法:推荐使用社区维护的适配仓库进行便捷安装,并提供了从源码编译的备选方案。文章重点解决了安装后编译ROS包时极易遇到的“shared_mutex”等C++标准库冲突问题,并给出了其他常见错误的排查与解决指南,帮助开发者顺利搭建稳定的ROS开发环境。

weixin_29295541的博客 366

CLion for Mac(m1)配置GCC编译器

条件:电脑已经下载过XCode 一. 下载HomeBrew homebrew是一款macos,linux下的包管理工具,我们需要使用他来下载GCC 下载方法: 1.打开终端(terminal) 2.输入 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" ps.有可能会遇到的问题 我当初下载挂了VPN,优快云上还有很多解决问题的方法,可以将错误信

supermario19的博客 7847

C++中std::distance使用

是一个用于计算两个迭代器之间元素个数的函数,常用于获取容器中两个元素之间的索引位置或计算偏移量。

qq_36812406的博客 744

盘点那些好用的SAP FIORI App(二) -上传凭证Upload Journal Entry

SAP FICO运维问题及解决方案分享

lijinbao171022的博客 1545

C++牛客网编程(五)

描述 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的,但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如,如果输入长度为7的数组[2,3,1,0,2,5,3],那么对应的输出是2或者3。存在不合法的输入的话输出-1 数据范围:0≤n≤10000 进阶:时间复杂度O(n) ,空间复杂度O(n) 思路:设置另外一个数组作为个数标志,直到大于1就输出 int duplicate(vector<int>.

weixin_45588765的博客 933

rsyslog交叉编译(armv7、armv8、aarch64、arm32平台通用)

该文档描述了如何交叉编译rsyslog到arm64嵌入式平台。

sinat_33909696的博客 1563

数学建模常用模型10 :数据包络(DEA)分析法(投入产出法)

数据包络分析是评价多输入指标和多输出指标的较为有效的方法,将投入与产出进行比较。它的结果包含的意思有: ①θ=1,DEA有效,表示投入与产出比达到最优 ②θ&lt;1,非DEA有效,表示投入与产出比没有达到最优,一般来说,θ越大说明效果越好。 数据包络分析是通过对投入的指标和产出的指标做了一个线性规划,并且进行变换后,然后根据其线性规划的对偶问题(线性规划对偶问题具有经济学意义),求解这个对...

HaLosec_Wei 9万+

C++ STL distance()函数(深入了解,一文学会)

我们知道,作用于同一容器的 2 个同类型迭代器可以有效指定一个区间范围。在此基础上,如果想获取该指定范围内包含元素的个数,就可以借助distance()函数。 distance() 函数用于计算两个迭代器表示的范围内包含元素的个数,其语法格式如下: template<class InputIterator> typename iterator_traits<InputIterator>::difference_type distance (InputIte...

断点 2262

DSP在线升级方案:TMS320C6678使用网络或者串口输出升级数据进行固件升级

下面这段先引用创龙的说明 IBL 运行后, 将从 NOR FLASH 或 NAND FLASH 的 0x00080000 地址引导 ELF/BBLOB 格式 用户程序。 当引导 ELF 格式用户程序时, IBL 会解析用户程序头部信息,并根据头部信息 拷贝不同的代码段至指定 CPU 内存地址,然后将 PC 指针跳转至_c_int00, 再运行用户程 序。当引导 BBLOB 格式用户程序时,由于无头部信息, IBL 会将用户程序拷贝至 0x9E000000 (该内存地址为 IBL 代码指定),并将 PC..

ToneChip的专栏,一个传统的嵌入式码农,裸机编程 1943

STL源码剖析---list

相较于vector的连续线性空间,list就显得复杂许多,它的好处是每次插入或删除一个元素,就配置或释放一个元素空间。因此,list对于空间的运用有绝对的精准,一点也不浪费。而且,对于任何位置的元素插入或元素移除,list永远是常数时间。       list不仅是一个双向链表,而且还是一个环状双向链表。另外,还有一个重要性质,插入操作和接合操作都不会造成原有的list迭代器失效,这在vecto

Hackbuteer1的专栏 1万+

PPT里文字太多如何排版-一口气教你7种布局瞬间让PPT高大上起来

PPT里全是文字且很拥挤怎么办?本篇教你使用7种不同的排版让你的PPT瞬间变得高大上起来。

打造全国最全的AI Agent开发知识领域的博客 5026

05 Transformer 到底解决了什么问题

Transformer 是现代大语言模型的底层骨架。本文不推公式,而是从 CNN、RNN/LSTM 的瓶颈讲起,解释 Transformer 如何通过自注意力同时解决长距离依赖和并行训练问题,并说明它为什么能支撑 GPT、BERT 和现代大模型的规模化。

老于的笔记的专栏 248

源码剖析:STL中序列式容器之list

本文详细介绍了STL中list容器的实现原理。list采用环状双向链表结构,每个节点包含前后指针和数据域。其迭代器为双向迭代器,支持增删操作而不失效。list通过精确内存管理实现高效操作,包括插入(insert/push)、删除(erase/pop)、合并(merge)、反转(reverse)和排序(sort)等。与vector相比,list在频繁增删场景下性能更优,但随机访问效率较低。文章通过源码分析展示了list的核心数据结构、内存管理机制和各类操作实现方法,为理解和使用STL list容器提供了参考

WildPointer的博客 910

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

深入解剖STL List:从源码剖析到相关接口实现

# 摘要 本文深入剖析STL中list双向链表的实现原理,从源码解析到手写实践全面展开。详细讲解list节点结构、迭代器设计、transfer核心操作及splice等高级功能实现。通过对比STL源码与手写实现,揭示list在插入删除操作上的高效特性、迭代器稳定性机制及与vector的适用场景差异。文章包含完整测试案例,帮助读者深入理解双向链表的设计精髓和STL容器的实现哲学。

燃于AC之乐的博客 1328

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

【STL源码剖析】从源码看 list:从迭代器到算法

本文深入剖析了STL中list容器的实现细节,适合已掌握C++模板和STL基础的开发者学习。文章从六个方面展开:概述list的优劣势;分析节点结构为双向循环链表;探讨迭代器设计与操作重载;揭示循环双向链表的数据结构;讲解构造与内存管理机制;介绍常用接口实现。重点解析了list通过哨兵节点实现"前闭后开"的特性,以及其特有的内存分配方式。文章通过源码分析,展示了STL中list的高效实现技巧,为开发者深入理解STL容器和数据结构提供了宝贵参考。

2401_87944878的博客 7963

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

C++ STL: list使用及源码剖析

list使用list常用函数及使用(1)登录后复制 #include <iostream> #include <list> #include <algorithm> int main() { // 创建list std::list<int> myList...

weixin_33918202的博客 169

STL源码剖析——list

相较于vector的连续线性空间,list就显得复杂许多,它的好处是每次插入或删除一个元素,就配置或释放一个元素空间。因此,list对于空间的运用有绝对的精准,一点也不浪费。而且,对于任何位置的元素插入或元素移除,list永远是常数时间。       list不仅是一个双向链表,而且还是一个环状双向链表。另外,还有一个重要性质,插入操作和接合操作都不会造成原有的list迭代器失效,这在vecto

Smile&搁浅 2007

STL之list源码剖析

STL之list源码剖析 相较于vector,使用list的好处是每次插入或删除一个元素,就配置或释放一个元素的空间。 list的节点: template struct  __list_node{          typedefvoid* void_pointer;          void_pointerprev;   //型别为void*。其实可设为__list_node*

walkerkalr的专栏 932

stl_list.h源码剖析

容器list双向环形链表 list相较于vector的连续线性空间,list显得复杂许多,好处是每次插入或者删除一个元素,就配置或释放一个元素空间。因此list对于空间的运用绝对精准,一点也不浪费。而且对于任何位置的元素插入和元素移除,list永远是常数时间<STL源码剖析> 相关图 节点设计 template <class T> struct __list_node { typedef void* void_pointer;//缺陷,使用时都得强转成_list_node类型

asladfa的博客 354

STL源码剖析笔记——list

STL源码剖析笔记——list

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值