stl源码剖析-序列式容器 之 list

  较久以前学过数据结构,对链表的定义和行为结构有过了解,所以阅读源码学习stl定义的list容器的并不算吃力。

  list与vector都是两个常用的容器,与vector不同,list不是连续线性空间的,list是一个双向链表。每次插入或者删除一个元素,将配置或者释放一个元素空间,因此,list对于空间的运用有着绝对的精准,不会造成浪费现象。而且对于任何位置的元素插入或者删除,其操作时间永远是常数时间。(缺点是不能进行随机的访问)

list节点

  list链表本身和list节点是分开设计的,以下是list节点的结构

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

  可以看出list节点是一个双向链表,next指向下一个节点,prev指向前一个节点

list的迭代器

  学过数据结构就知道,链表的一个特点是其分配空间不必固定在一段连续的存储空间中,所以list不能像vector一样以普通指针作为迭代器,因为其节点不能保证在存储空间中连续存在。list迭代器必须有能力指向其list节点,并有能力进行正确的递增、递减、取值、成员存取等操作。

  由于STL list是一个双向链表,迭代器必须具备前移、后移的能力,所以list提供的是Bidirectional Iterators (双向迭代器)。

  在vector中,对其进行插入操作有可能会使其满载并且溢出,这样vector便需要重新配置空间,这样原有的迭代器会全部失效。而list在进行插入和接合操作都不会造成原有的list迭代器失效,即便是其删除操作,也只有“指向被删除元素”的迭代器失效,其他迭代器不受影响。

template<class T,class Ref,class Ptr>
  struct _list_iterator{
      typedef _list_iterator<T,T&,T*> iterator;
      typedef _list_iterator<T,T&,T*> iterator;
  ?
      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_iterator(link_type x):node(x){}
      _list_iterator(){}
      _list_iterator(const iterator& x):node(x.node){}

      bool operator==(const self& x) const {return node==x.node;}
      bool operator!=(const self& x) const {return node!=x.node;}

      reference operator*() const {return (*node).data;}

      reference operator->() const {return &(operator*());}

      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的数据结构

  SGI list不仅是一个双向链表,而且是一个环状的双向链表。

template<class T,class Alloc = alloc> //缺省使用alloc为配置器
  class list{  
  protected :  
      typedef __list_node<T> list_node ;  
  public  :  
      typedef list_node* link_type ;  
  protected :  
      link_type node ; //只要一个指针,便可以表示整个环状双向链表  
      ...
  };

如果让指针node指向刻意置于尾端的一个空白节点,node就能符合stl对于前闭后开区间的要求,成为last迭代器。这样以下函数便能轻易完成

iterator begin() { return (link_type)((*node).next); }
iterator end() { return node; }

bool empty() const { return node->next == node; }

size_type size() const
{
    size_type result = 0;
    distance(begin(), end(), result);//SGI里面的distance函数作用就是遍历链表,十分影响性能
    return result;
}

reference front() { return *begin(); }
reference back() { return *(--end()); }

list的构造与内存管理

  list的构造方式有很多,这里列出缺省情况下的构造函数

/ 默认allocator为alloc
template <class T, class Alloc = alloc>
class list
{
...
public:
    list() { empty_initialize(); }
protected:
    // 专属空间配置器,配置单位为一个节点大小
    typedef simple_alloc<list_node, Alloc> list_node_allocator;

    // 建立空链表
    void empty_initialize()
    {
        node = get_node();
        node->next = node;
        node->prev = node;
    }

    // 配置一个节点,不进行构造
    link_type get_node() { return list_node_allocator::allocate(); }

    // 释放一个节点, 不进行析构
    void put_node(link_type p) { list_node_allocator::deallocate(p); }

    // 配置并构造一个节点
    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);
    }
...
}

  insetr()是一个重载函数,同样有很多种形式,其中最简单如下,首先配置并构造一个节点,然后在尾端进行适当指针操作插入新节点(push_back()和push_front插入新元素时都会调用insert())

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

list的元素操作

  list的元素操作很多,无论是简单的插入删除清除还是迁移,大部分都不难,下面只列出部分常用的操作,有兴趣可以详细阅读《stl源码剖析》第四章关于list的内容,或者直接下载源码来研究

void push_front(const T&x){
  insert(begin(),x);
  }

 iterator erase(iterator position){  
      link_type next_node=link_type(position.node->next);  
      link_type prev_node=link_type(position.node->prev_nodext);  
      prev_node->next=next_node;  
      next_node->prev=prev_node;  
      destroy_node(position.node);  
      return iterator(next_node);  
  } 

void pop_front(){
      erase(begin());
  } 

void pop_back(){
      iterator i=end();
      erase(--i);
  } 

//将某连续范围的元素迁移到某个特定位置之前。技术上讲很简单,节点直接的指针移动而已。
void transfer(iterator position, iterator first, iterator last) {  
      if (position != last) {  
        (*(link_type((*last.node).prev))).next = position.node;
        (*(link_type((*first.node).prev))).next = last.node;      
        (*(link_type((*position.node).prev))).next = first.node;  
        link_type tmp = link_type((*position.node).prev);       
        (*position.node).prev = (*last.node).prev;               
        (*last.node).prev = (*first.node).prev;                  
        (*first.node).prev = tmp;                               
      }  
    }  

原文地址:https://www.cnblogs.com/LEEYATWAH/p/11707589.html

时间: 2024-11-07 19:11:31

stl源码剖析-序列式容器 之 list的相关文章

stl源码剖析-序列式容器 之 vector

vector的数据安排以及操作方式,与array(c++自身提供的序列式容器)非常相似.两者唯一的差别在于空间的运用的灵活性.array是静态空间,一旦配置了将不能随意更改其大小,若要更改需要重新配置一块新的空间,如何将元素从旧址中一一搬迁,再释放原来的系统.而vector是动态空间,随着元素的加入,它的内部机制会自行扩充空间已容纳新元素.(实际vector每次动态分配的空间大小是有限的,超过了这个临界值同样是要像array一样进行元素搬迁,下面将会进行详细介绍)vector 是最常用的 C++

STL源码剖析——序列式容器#2 List

list就是链表的实现,链表是什么,我就不再解释了.list的好处就是每次插入或删除一个元素,都是常数的时空复杂度.但遍历或访问就需要O(n)的时间. List本身其实不难理解,难点在于某些功能函数的实现上,例如我们会在最后讨论的迁移函数splice().反转函数reverse().排序函数sort()等等. list的结点 设计过链表的人都知道,链表本身和链表结点是不一样的结构,需要分开设计,这里的list也不例外,以下是STL list的结点结构: 1 template <class T>

STL源码剖析(4):容器(vector)

容器是很多人对STL的第一印象,vector,stack,queue,set,map等等都是容器. 这里先介绍 STL中的序列式容器. 所谓序列式容器,其中的元素可序(ordered),但未必有序(sorted).C++ 本身提供了一个序列式容器--数组(array),STL中还提供了向量(vector),链表(list),堆栈(stack),队列(queue),优先队列(priority queue)等,其中stack和queue只是将deque(双端队列)设限而得到的,技术上可以被归为一种配

STL源码剖析—序列容器

对于STL中的容器,存在一定的内含关系,例如,heap内含一个vector,priority-queue内含一个hep,stack和queue都含有一个deque,set/map/multiset/multimap都内含一个RB-tree,hash_x都内含一个hashtable. 对于序列容器来说,vector和list的插入都是在指向迭代器之前进行插入.同时需要注意的就是,对于vector来说,调用erase()函数也就是清除了几个连续空间上的元素,调用其析构函数,并没用释放原来元素占用的内

STL源码剖析(4):容器(list)

相较于vector的连续线性空间,list就显得复杂许多,它的好处是每次插入或删除一个元素,就配置或释放一个元素空间.因此,list对于空间的运用有绝对的精准,一点也不浪费.而且,对于任何位置的元素插入或元素移除,list永远是常数时间. list 内部为双向链表,内部元素互相以link串接起来,每个元素都知道其前一个元素以及下一个元素的位置. template <class T> struct __list_node { typedef void* void_pointer; void_po

STL源码剖析 容器 stl_vector.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie vector ---------------------------------------------------------------------- 描述: 1.迭代器 vector 维护的是一个连续线性空间,它的迭代器是普通指针, 能满足 RandomAccessIterator 所有必要条件:operator*, operator->,operator++,operator--,

STL源码剖析 容器 stl_set.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie set ------------------------------------------------------------------------ 所有元素都会根据元素的键值自动被排序. 不可以通过 set 的迭代器改变 set 的元素值.因为 set 元素值就是其键值,关系到 set 元素的排列规则. set<T>::iterator 被定义为底层 RB-tree 的 const

STL源码剖析 容器 stl_tree.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie RB-tree(红黑树) -------------------------------------------------------------------------- 平衡二叉搜索树 --> 平衡可提高搜索效率 常见的平衡二叉搜索树有: AVL-tree(任何节点的左右子树高度相差最多 1).红黑树.AA-tree AVL-tree 破坏平衡的情况及恢复平衡的方法 恢复时要先找到失

STL源码剖析 容器 stl_map.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie map -------------------------------------------------------------------------------- 所有元素都会根据元素的键值自动被排序. map的所有元素都是 pair,同时拥有实值和键值. 不可以修改元素的键值,因为它关系到 map 元素的排列规则 可以修改元素的实值,因为它不影响 map 的排列规则 map ite