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

  list就是链表的实现,链表是什么,我就不再解释了。list的好处就是每次插入或删除一个元素,都是常数的时空复杂度。但遍历或访问就需要O(n)的时间。

  List本身其实不难理解,难点在于某些功能函数的实现上,例如我们会在最后讨论的迁移函数splice()、反转函数reverse()、排序函数sort()等等。

list的结点

  设计过链表的人都知道,链表本身和链表结点是不一样的结构,需要分开设计,这里的list也不例外,以下是STL list的结点结构:

1 template <class T>
2 struct __list_node {
3     typedef void* void_pointer;
4     void_pointer next;
5     void_pointer prev;
6     T data;
7 };

  从结点结构可以看出,list是一个双向链表,有指向前一结点的prev指针,指向下一结点的next指针。

list的迭代器

  显然,list的迭代器本身是什么类型早已由其本身的数据结构所决定,list的双向链表,不支持随机存取,只能是双向迭代器(Bidirectional Iterators)。另外,list的迭代器应该支持正确的递增、递减、取值、成员取用等操作。

  以下是list迭代器的源码:

 1 template<class T, class Ref, class Ptr>
 2 struct __list_iterator { // 未继承 std::iterator
 3     typedef __list_iterator<T, T&, T*> iterator;
 4     typedef __list_iterator<T, const T&, const T*> const_iterator;
 5     typedef __list_iterator<T, Ref, Ptr> self;
 6     // 未继承 std::iterator,所以必须自行撰写五个必要的迭代器相应类型
 7     typedef bidirectional_iterator_tag iterator_category; // (1)双向迭代器类型
 8     typedef T value_type; // (2)
 9     typedef Ptr pointer; // (3)
10     typedef Ref reference; // (4)
11     typedef __list_node<T>* link_type;
12     typedef size_t size_type;
13     typedef ptrdiff_t difference_type; // (5)
14     link_type node; // node就是一个指向链表节点的指针
15
16     __list_iterator(link_type x) : node(x) {}
17     __list_iterator() {}
18     __list_iterator(const iterator& x) : node(x.node) {}
19     // 迭代器必要的操作
20     bool operator==(const self& x) const { return node == x.node; }
21     bool operator!=(const self& x) const { return node != x.node; }
22     // * 取值符号,data是T类型,而reference是T&,返回reference,说明支持当作左值
23     reference operator*() const { return (*node).data; }
24 #ifndef __SGI_STL_NO_ARROW_OPERATOR
25     //不太能理解
26     pointer operator->() const { return &(operator*()); }
27 #endif /* __SGI_STL_NO_ARROW_OPERATOR */
28
29     //关键:对迭代器累加 1,就是前进一个节点
30     self& operator++() {
31         node = (link_type)((*node).next);    //next为void*,強制转为指向节点的指针类型(__list_node<T>*)
32         return *this;    //迭代器对象本身没有前进后退这一说法,前进后退的是隐藏在迭代器里的成员node
33     }
34     self operator++(int) {    //后缀++
35         self tmp = *this;
36         ++*this;
37         return tmp;
38     }
39     // 对迭代器累减 1,就是后退一个节点
40     self& operator--() {
41         node = (link_type)((*node).prev); // 同理
42         return *this;
43     }
44     self operator--(int) {    //后缀--
45         self tmp = *this;
46         --*this;
47         return tmp;
48     }
49 };

  于我而言,我觉得都比较容易理解,唯一不太懂的就是operator->()函数,这里讲一下我的理解,但不知道对不对,其返回的是&(operator*()),而operator*()我们知道返回的是data变量的引用,前面有个取址符号&,说明返回的是data变量的地址?然后返回的类型是pointer,即T*,总的来说返回的是一个T类型指针,该指针指向data变量所在的地址?好像合理,那该怎么使用?可能是it->data时我们能继续当它是指针然后it->data->?

list的数据结构

  由上述可知,list是一个双向链表,但不仅如此,它还是个环状双向链表,为什么这么设计?因为这样用一个节点指针就能表示整个链表,何为表示整个链表?就是说我们能够从这一个节点出发,顺序遍历整个链表以及逆序遍历整个链表,而非环状不能做到如此,除非用两个节点(一个头、一个尾)才能表示整个链表。双向链表做成环状很简单,我们用一个节点指针指向链表尾部的一个空白结点(也可以说是头部之前的一个空白结点),该空白结点连接了链表的头部和尾部。

 1 template <class T, class Alloc = alloc> // 預設使用 alloc 為配置器
 2 class list {
 3 protected:
 4     typedef __list_node<T> list_node;
 5 public:
 6     typedef list_node* link_type;
 7
 8 protected:
 9     link_type node; // 永远指向最后结点的下一节点。该结点无元素值,代表空节点。
10                     // 其 next 节点永远是头节点
11 };

  这可能会有疑问,为什么不让首尾直接相连,而要隔一个空白结点呢?因为有一个空白结点,符合STL对于区间“前闭后开[, )”的要求,成为last迭代器所指。这么一来,一些功能函数的设计就变得很简单:

 1 iterator begin() { return (link_type)((*node).next); }
 2 const_iterator begin() const { return (link_type)((*node).next); }
 3
 4 iterator end() { return node; }
 5 const_iterator end() const { return node; }
 6
 7 bool empty() const { return node->next == node; }
 8 size_type size() const {
 9     size_type result = 0;
10     distance(begin(), end(), result);
11     return result;
12 }
13
14 // 取头节点的內容(元素值)。
15 reference front() { return *begin(); }
16 const_reference front() const { return *begin(); }
17 // 取尾节点的內容(元素值)。
18 reference back() { return *(--end()); }
19 const_reference back() const { return *(--end()); }

list的构造与内存管理

  与Vector类似,list也定义了一个simple_alloc<>对象来负责空间配置事宜,其第一个类型参数为结点类__list_node<T>,为的是每次都分配一个节点大小的空间,第二个类型参数为alloc空间配置器。

1 template <class T, class Alloc = alloc> // 预设使用alloc为配置器
2 class list {
3 protected:
4     typedef void* void_pointer;
5     typedef __list_node<T> list_node;
6     // 专属分配空间的对象,每次配置一个节点的大小
7     typedef simple_alloc<list_node, Alloc> list_node_allocator;

  以下4个函数分别用来配置、释放、构造、销毁一个节点:

 1 protected:
 2     // 配置一个节点并将其返回
 3     link_type get_node() { return list_node_allocator::allocate(); }
 4     // 释放一个节点
 5     void put_node(link_type p) { list_node_allocator::deallocate(p); }
 6     // 构造一个节点(配置空间并赋予值)并返回
 7     link_type create_node(const T& x) {
 8         link_type p = get_node();
 9         __STL_TRY{
10             construct(&p->data, x);
11         }
12         __STL_UNWIND(put_node(p));
13         return p;
14     }
15     // 摧毁一个节点(析构并释放)
16     void destroy_node(link_type p) {
17         destroy(&p->data);
18         put_node(p);
19     }

  list提供了很多种构造函数,第一个就是默认构造函数,允许我们不指定任何参数而创建一个空的list:

1 public:
2     list() { empty_initialize(); } // 产生一个空链表
3 protected:
4     void empty_initialize() {
5         node = get_node(); // 配置一个节点空间,令 node 指向它。为空白节点
6         node->next = node; // 令 node 头尾都指向自己,不设元素值。
7         node->prev = node;
8     }

  第二个就是比较常用的,构造n个值为value的节点,第三个就是构造n个结点,内容用T类型的默认构造函数填充,两个构造函数虽然用法不一,但实际上都转调用了同一个函数:

 1 public:
 2     list(size_type n, const T& value) { fill_initialize(n, value); }
 3     list(int n, const T& value) { fill_initialize(n, value); }
 4     list(long n, const T& value) { fill_initialize(n, value); }
 5     explicit list(size_type n) { fill_initialize(n, T()); }
 6 protected:
 7     void fill_initialize(size_type n, const T& value) {
 8             empty_initialize();
 9         __STL_TRY{
10             insert(begin(), n, value);
11         }
12         __STL_UNWIND(clear(); put_node(node));
13     }

  对就是fill_initialize(),而fill_initialize()自己也精明的很,我就创建一个空链表,然后就撒手不管了,全交给insert()函数,能看出这样能把构造变成原子操作,能就n个节点全部构造好,不然就一个都不构造。另外,在push_back()函数里也是把自己的工作外包了给insert()函数,可见insert()函数承担了太多,当然我们会在稍后重点学习Insert()函数。

1     // 安插一个节点,做为头节点
2     void push_front(const T& x) { insert(begin(), x); }
3     // 安插一个节点,做为尾节点
4     void push_back(const T& x) { insert(end(), x); }

  insert()具有多个版本,其中最简单的一种,就是在指定位置插入一个节点:

 1     // 在迭代器 position 所指位置安插一個节点,內容为 x。
 2     iterator insert(iterator position, const T& x) {
 3         link_type tmp = create_node(x); // 产生一个节点(值为x)
 4                                         // 调整前后指针,使 tmp 安插进去。
 5         tmp->next = position.node;
 6         tmp->prev = position.node->prev;
 7         (link_type(position.node->prev))->next = tmp;
 8         position.node->prev = tmp;
 9         return tmp;
10     }

  而其余的版本都是在反复调用上面这个版本罢了:

 1   template <class T, class Alloc>
 2     void list<T, Alloc>::insert(iterator position, size_type n, const T& x) {
 3         for (; n > 0; --n)
 4             insert(position, x);
 5     }
 6     template <class T, class Alloc>
 7     void list<T, Alloc>::insert(iterator position,
 8         const_iterator first, const_iterator last) {
 9         for (; first != last; ++first)
10             insert(position, *first);
11     }
12     template <class T, class Alloc>
13     void list<T, Alloc>::insert(iterator position, const T* first, const T* last)
14     {
15         for (; first != last; ++first)
16             insert(position, *first);
17     }
18     void list<T, Alloc>::insert(iterator position,
19         InputIterator first, InputIterator last) {
20         for (; first != last; ++first)
21             insert(position, *first);
22     }

  所谓的插入,就是指 指定位置的前方,这是STL的插入规范。另外,不像vector,list所有的插入操作都不会影响现有迭代器的有效性。

list的元素操作

  • erase(iterator position) —— 移除迭代器position所指节点
1     iterator erase(iterator position) {
2         //断开当前节点连接,并将前后节点相连
3         link_type next_node = link_type(position.node->next);
4         link_type prev_node = link_type(position.node->prev);
5         prev_node->next = next_node;
6         next_node->prev = prev_node;
7         destroy_node(position.node);
8         return iterator(next_node);
9     }

  • pop_front() —— 移除头节点
1 void pop_front() { erase(begin()); }
  • clear() —— 清除所有节点(整个链表)
 1     template <class T, class Alloc>
 2     void list<T, Alloc>::clear()
 3     {
 4         link_type cur = (link_type)node->next; // 切记,list类内有一node节点指针指向链表末尾的空白结点,这里就是begin()
 5         while (cur != node) { // 遍历链表
 6             link_type tmp = cur;
 7             cur = (link_type)cur->next;
 8             destroy_node(tmp); // 逐一摧毁节点
 9         }
10         // 恢復 node 原始狀態
11         node->next = node;
12         node->prev = node;
13     }
  • remove(const T& value) —— 将值为value的所有元素移除
 1     template <class T, class Alloc>
 2     void list<T, Alloc>::remove(const T& value) {
 3         iterator first = begin();
 4         iterator last = end();
 5         while (first != last) { // 遍历链表
 6             iterator next = first;
 7             ++next;        //next指针负责前进一格,并与之比较
 8             if (*first == value) erase(first); // 找到就移除
 9             first = next;
10         }
11     }
  • unique() —— 移除值相同的连续元素,只有相同且连续的元素才会被移除,移除剩一个
 1     template <class T, class Alloc>
 2     void list<T, Alloc>::unique() {
 3         iterator first = begin();
 4         iterator last = end();
 5         if (first == last) return;
 6         iterator next = first;
 7         //next前进一格探路,相同排掉,不同叫first跟上
 8         while (++next != last) {
 9             if (*first == *next)
10                 erase(next);
11             else
12                 first = next;
13             next = first;
14         }
15     }

  比较难的几个函数来了,相比于上面这些小打小闹的弟弟,这些函数确实不易理解,尤其是排序函数sort(),其高超的算法逻辑使我瞠目结舌,作者造轮子的能力太强了。

  • transfer(iterator position, iterator first, iterator last) —— 将[first, last)内的所有元素移动到position之前。
 1 protected:
 2     void transfer(iterator position, iterator first, iterator last) {
 3         if (position != last) {
 4             //处理各节点的next
 5             (*(link_type((*last.node).prev))).next = position.node; // (1)    last的上一结点(next)与position相连
 6             (*(link_type((*first.node).prev))).next = last.node; // (2)        first的上一节点(next)与last相连
 7             (*(link_type((*position.node).prev))).next = first.node; // (3)    position的上一节点(next)与first相连
 8
 9             link_type tmp = link_type((*position.node).prev); // (4)        用一节点指针记录position的上一节点tmp,因为下一步position的上一节点就应该是last的上一节点了
10
11             //处理各节点的prev
12             (*position.node).prev = (*last.node).prev; // (5)                position(prev)与last的上一节点相连
13             (*last.node).prev = (*first.node).prev; // (6)                    last节点(prev)与first的上一节点相连
14             (*first.node).prev = tmp; // (7)                                first节点(prev)与原是position上一节点的节点tmp相连
15         }
16     }

  要注意的是,transfer所接受的区间是没有限制的(从源码也可以看出),这意味着[first, last)与position可以来自同一个链表,甚至position就在[first, last)区间内都行,只是从结果来看前者还能得到想要的答案,后者就有点奇怪了。

  从protected可知,我们并不能直接使用transfer,而是使用到transfer的公开接口为:

  • splice(iterator position, list& x) —— 将x接合与position所指位置前,注意x必须不同于*this(调用者本身),将自身链表接合在自身链表的某一位置上毫无意义。
1 void splice(iterator position, list& x) {
2  if (!x.empty())
3  transfer(position, x.begin(), x.end());
4  }
  • splice(iterator position, list&, iterator i) —— 将 i 所指元素接合于position所指位置之前,position与 i 可来自于同一链表
1     void splice(iterator position, list&, iterator i) {
2         iterator j = i;
3         ++j;
4         if (position == i || position == j) return;        //position == j 说明i已经在position前面了
5         transfer(position, i, j); //[i, j)
6     }
  • merge(list<T, Alloc>& x) —— 将 x 合并到*this身上。两个lists的内容都必须经过递增排序,注意,这是链表自底向上归并排序用到的重要函数。
 1     template <class T, class Alloc>
 2     void list<T, Alloc>::merge(list<T, Alloc>& x) {
 3         iterator first1 = begin();
 4         iterator last1 = end();
 5         iterator first2 = x.begin();
 6         iterator last2 = x.end();
 7         // 注意:前提是,兩个 lists 都已经过递增排序,
 8         while (first1 != last1 && first2 != last2)
 9             if (*first2 < *first1) {
10                 iterator next = first2;
11                 transfer(first1, first2, ++next); //[first2,++first2) 放在first1所指位置的前面
12                 first2 = next;
13             }
14             else
15                 ++first1;
16         if (first2 != last2) transfer(last1, first2, last2);        //如果first1已经到尾而first2还有,将剩下的全部放到first1后面
17     }
  • reverse() —— 反转链表
 1     template <class T, class Alloc>
 2     void list<T, Alloc>::reverse() {
 3         // 以下判断,如果是空白链表,或仅有一个元素,就不做任何动作。
 4         // 使用 size() == 0 || size() == 1 來判断,虽然也可以,但是比较慢。
 5         if (node->next == node || link_type(node->next)->next == node) return;
 6         iterator first = begin();
 7         ++first;
 8         while (first != end()) {
 9             iterator old = first;
10             ++first;
11             transfer(begin(), old, first);    //逐个元素往链表头前面移动,最终反转
12         }
13     }

  因为STL的算法sort()只接受随机迭代器(Random Access Iteartor),但list只有双向迭代器(Bidirectional Iterator),所以不能使用,为此STL为list设计了专有的sort(),侯捷老师书上说该函数使用了quick sort,但我觉得它更像是merge sort。因为丝毫没有快排的特征。存疑。

 1     template <class T, class Alloc>
 2     void list<T, Alloc>::sort() {
 3         // 以下判断,如果是空白链表,或仅有一个元素,就不做任何动作。
 4         if (node->next == node || link_type(node->next)->next == node) return;
 5         // 我们应该知道,归并排序一般需要一个临时数组来存放合并后的数据
 6         list<T, Alloc> carry;
 7         list<T, Alloc> counter[64];        //这个就是临时数组,第i个链表存放2的i次方个数据,设计者认为64次合并已经是足够大了,毕竟2的64次方是个很大的数据量了。
 8         int fill = 0;
 9         while (!empty()) {
10             carry.splice(carry.begin(), *this, begin());    //只要调用者的链表非空,就将链表的头节点移动到carry里面,每次就移一个节点,就是头节点。注意由transfer源码知,是移动而非复制
11                 int i = 0;
12                 //i每次从0开始,这说明每次都会按顺序遍历counter的各个连续非空链表,空就退出
13                 //进入到循环,意味着counter[i]非空
14                 //而carry绝不会为空,因为从循环内得知,先把carry数组合并到counter[i]里,然后又把它放回carry里,所以carry绝非空
15                 //从循环内的carry.swap(counter[i++])得知carry存放的都是上一个counter数据(因为是先swap再自增i再进入下一循环),而counter[i]只要是非空,里面存放的数据量肯定就是2的i次方
16                 //carry存放的也是2的i次方的数据量,而counter[i]本身也存放了2的i次方的数据量,两者一合并,就变成了2的i+1次方的数据量,已经大于counter[i]所能存放的数据量,所以把它转回到carry里,在下一循环中放到下一个counter链表中(也即是counter[i++],这也解释了为什么本次循环中carry存放的也是2的i次方的数据量,因为该数据来自上一次循环的counter[i-1])
17             while (i < fill && !counter[i].empty()) {
18                 counter[i].merge(carry);
19                 carry.swap(counter[i++]);
20             }
21             //22
23             //这里有两个作用
24             //1.是因为i == fill而终止的循环,此时counter[i]肯定为空(在此之前从未使用过counter[fill]),而carry肯定有数据(来自counter[i-1]),把carry数据转给空的counter[i],此时counter[i]的数据量为2的i次方
25             //  为什么是2的i次方,是因为i == fill而终止的循环,代表count[i-1]放的数据已经超过2的i-1次方,所以转给carry,并把i自增,终止循环,才能给到counter[i]
26             //2.是因为counter[i]为空而终止的循环,将存放在carry的来自上一个counter的数据转给counter[i],
27             carry.swap(counter[i]);
28             //fill代表的是目前开放的最大counter,只有i==fill才自增,而其上一句是carry.swap(counter[i]);将carry的数据转到counter[fill]里,说明只有当counter[fill]有数据了,fill才自增(才开放下一个counter)
29             //如果i没到fill,说明目前从调用者链表里拿的数据量还不足2的fill次方。不足以开放下一个counter。
30             if (i == fill) ++fill;
31         }
32         for (int i = 1; i < fill; ++i)
33             counter[i].merge(counter[i - 1]);
34         swap(counter[fill - 1]);
35     }

  我真的很想把这段代码用文字的方式解释清楚,我尽力了,但还是太难了,上面的注释看得懂最好,看不懂最好自己用数据走一下这个函数的流程,大概就能懂了。我对这段代码真是佩服得五体投地。是真的只可意会不可言传。

  

原文地址:https://www.cnblogs.com/MisakiJH/p/11726726.html

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

STL源码剖析——序列式容器#2 List的相关文章

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

较久以前学过数据结构,对链表的定义和行为结构有过了解,所以阅读源码学习stl定义的list容器的并不算吃力. list与vector都是两个常用的容器,与vector不同,list不是连续线性空间的,list是一个双向链表.每次插入或者删除一个元素,将配置或者释放一个元素空间,因此,list对于空间的运用有着绝对的精准,不会造成浪费现象.而且对于任何位置的元素插入或者删除,其操作时间永远是常数时间.(缺点是不能进行随机的访问) list节点 list链表本身和list节点是分开设计的,以下是li

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

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

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