STL源码剖析阅读笔记四（序列容器list）

已于 2022-03-08 17:45:50 修改
阅读量667 收藏
点赞数 1
分类专栏： C++基础 文章标签： c++ 容器 运维
于 2022-03-04 15:23:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qw225967/article/details/123261179
版权

一、概述

  list和上一章的vector都是我们平时开发最常用到的容器。但与vector不一样的是，list并非一个绝对固定的连续空间的容器，之所以设计成这样还是考虑了连续空间删除插入的时间消耗。STL的list事实上是一个双向链表，了解链表概念的应该明白，这种前后可移动的链表结构提供了非常灵活的操作性。

二、定义

2.1 节点形式

  它的节点形式可以比较形象化地展示为下图的样子：
在这里插入图片描述

  而具体的代码也很简单：

template <class T> struct __list_node {
    typedef void* void_pointer;
    void_pointerprev; //型別為void*。其實可設為__list_node<T>* void_pointer next;
    T data;
};

2.2 迭代器

  这里过多地赘述迭代器的介绍，但不得不提的一点是：list的迭代器和vector是有比较大区别的，也就是list不能使用原生指针作为迭代器，而是需要另外设计结构的。
在这里插入图片描述

  它的结构很容易理解，也就是我们需要把拼接工作和抽离工作封装的足够简单即可。

template<class T, class Ref, class Ptr> 
struct __list_iterator {
	typedef __list_iterator<T, T&, T*> iterator; 
    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 的節點
   // constructor
   __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; } 
    
    // 以下對迭代器取值(dereference)，取的是節點的資料值。
	reference operator*() const { return (*node).data; }
	
    // 以下是迭代器的成員存取(member access)運算子的標準作法。
    pointer operator->() const { return &(operator*()); }
	
    // 對迭代器累加 1，就是前進一個節點 
    self& operator++()
        node = (link_type)((*node).next);
        return *this;
   	}
	self operator++(int) 
        self tmp = *this; 
		++*this;
		return tmp;
	}
	// 對迭代器遞減 1，就是後退一個節點 
	self& operator--()
    	node = (link_type)((*node).prev);
     	return *this;
   	}
	self operator--(int) self tmp = *this; 
	--*this;
	return tmp;
	} 
};

2.3 节点结构

  上面提到，STL的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; // 只要一個指標，便可表示整個環狀雙向串列
	... 
};

  试想我们需要一个不断向后添加节点的标记，那么我们整个操作其实都必须要依赖一个节点的指针去进行。link_type 就是对整个node指针换了个名。然后把所有的头和尾都标记起来，让我们用的时候可以直接找到头尾。

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); //全域函式，第3章。 
    return result;
}
// 取頭節點的內容(元素值)。
reference front() { return *begin(); } 

// 取尾節點的內容(元素值)。
reference back() { return *(--end()); }

  它前后取值的操作都可以形象地展示为下图：
在这里插入图片描述

三、操作中理解list

  最关键的操作就是基于transfer()这个函数来实现的：

// 將 [first,last) 內的所有元素搬移到 position 之前。
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;
	  } 
}

  它的逻辑实际上是下图的形式实现的：
在这里插入图片描述

3.1 环形链表

  前面中提到list是一个双向链表，当我们不断地向后迭代，它会打印出什么情况呢？如列代码，我们放入4个节点后就不断地进行迭代器偏移：

#include <iostream>
#include <list>

int main() {
  std::list<int> l;
  l.push_back(1);
  l.push_back(2);
  l.push_back(3);
  l.push_back(4);

  auto iter = l.begin();
  for(int i=0; i<l.size()*2;i++) {
    std::cout << *iter << " ";
    iter++;
  }
  std::cout << std::endl;



  std::cout << "Hello, World!" << std::endl;
  return 0;
}

  得到的结果是：
在这里插入图片描述
  最后一个节点竟然被打印了两次，事实上是因为最后的一个节点后面还有一个标记结束的end节点，这个节点的内容和最后一个节点的值相同。

#include <iostream>
#include <list>

int main() {
  std::list<int> l;
  l.push_back(1);
  l.push_back(2);
  l.push_back(3);
  l.push_back(4);

  auto iter = l.begin();
  for(int i=0; i<=l.size()*2;i++) {
    std::cout << *iter << " ";
    iter++;
  }
  std::cout << std::endl;
  auto iter2 = l.end();
  std::cout << *iter2 << std::endl;
  l.push_back(5);
  auto iter3 = l.end();
  std::cout << *iter3 << std::endl;


  std::cout << "Hello, World!" << std::endl;
  return 0;
}

在这里插入图片描述

3.2 合并算法

#include <iostream>
#include <list>

int main() {
  std::list<int> l1;
  std::list<int> l2;
  l1.push_back(1);
  l1.push_back(2);
  l2.push_back(3);
  l2.push_back(4);


  l1.merge(l2);
  for(auto iter = l1.begin();iter!=l1.end();iter++) {
    std::cout << *iter << " ";
  }
  std::cout << std::endl;
  std::cout << "Hello, World!" << std::endl;
  return 0;
}

3.3 翻转算法

#include <iostream>
#include <list>

int main() {
  std::list<int> l;
  l.push_back(1);
  l.push_back(2);
  l.push_back(3);
  l.push_back(4);

  for(auto iter = l.begin();iter!=l.end();iter++) {
    std::cout << *iter << " ";
  }
  std::cout << std::endl;
  l.reverse();
  for(auto iter = l.begin();iter!=l.end();iter++) {
    std::cout << *iter << " ";
  }
  std::cout << std::endl;


  std::cout << "Hello, World!" << std::endl;
  return 0;
}

在这里插入图片描述
  它的源码实现为：

// reverse() 將 *this 的內容逆向重置 
template <class T, class Alloc> void 
list<T, Alloc>::reverse() {
// 以下判斷，如果是空白串列，或僅有一個元素，就不做任何動作。
// 使用 size() == 0 || size() == 1 來判斷，雖然也可以，但是比較慢。 
if (node->next == node || link_type(node->next)->next == node)
return;
  iterator first = begin();
  ++first;
  while (first != end()) {
   iterator old = first;
   ++first;
   transfer(begin(), old, first);
} }

  整体的逻辑还是比较简单的。

3.4 排序算法

#include <iostream>
#include <list>

int main() {
  std::list<int> l;
  l.push_back(1);
  l.push_back(3);
  l.push_back(2);
  l.push_back(4);
  l.sort();
  for(auto iter = l.begin();iter!=l.end();iter++) {
    std::cout << *iter << " ";
  }
  std::cout << std::endl;
  std::cout << "Hello, World!" << std::endl;
  return 0;
}

在这里插入图片描述

  实际在STL中使用的是快排来实现排序的，以上都使用了transfer的方法来进行。


//list不能使用STL演算法 sort()，必須使用自己的 sort()memberfunction， // 因為 STL 演算法 sort() 只接受 RamdonAccessIterator.
// 本函式採用 quick sort.
template <class T, class Alloc>
void list<T, Alloc>::sort() {
// 以下判斷，如果是空白串列，或僅有一個元素，就不做任何動作。
// 使用 size() == 0 || size() == 1 來判斷，雖然也可以，但是比較慢。 
if (node->next == node || link_type(node->next)->next == node)
	return;
// 一些新的 lists，做為中介資料存放區 list<T, Alloc> carry;
list<T, Alloc> counter[64];
int fill = 0;
  while (!empty()) {
   carry.splice(carry.begin(), *this, begin());
   int i = 0;
   while(i < fill && !counter[i].empty()) {
     counter[i].merge(carry);
     carry.swap(counter[i++]);
   }
   carry.swap(counter[i]);
   if (i == fill) ++fill;
  }
  for (int i = 1; i < fill; ++i)
    counter[i].merge(counter[i-1]);
  swap(counter[fill-1]);
}
dog head
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL源码剖析读书笔记
01-26
STL经典著作的读书笔记。按章节写的，算是一份不错的总结吧
STL源码剖析笔记-4序列式容器
小二杰的博客
04-01 428
序列式容器 1 容器的概观与分类 2 vector 3 list 4 deque 5 stack 6 queue 7 heap 8 priority_queue 9 slist 4 序列式容器4.1 容器的概观与分类 序列式容器array、vector、heap、priority-queue、list、slist、deque、stack、queue. 关联式容器RB-tree、set、map、mul
《STL源码剖析》学习笔记之四——序列式容器
HQ的专栏
08-27 682
STL中序列式容器包含如下：array,vector,list,deque,priority-queue,slist,stack,queue。其中array属于C++语言的内建的数据结构，另外stack和queue属于适配器，两者均采用deque作为底层的数据容器。    （一）  vector 1、特点：动态空间，随着元素的加入，内部机制会自行扩充空间以容纳新元素。“配置新空间，数据移动
侯捷——STL源码剖析 笔记
热门推荐
weixin_45067603的博客
02-04 1万+
侯捷——STL源码剖析 笔记 1.总览 1.STL六大部件之间的关系 在下图中，我们使用了如下： 1.一个容器vector 2.使用vector时，使用分配器分配内存 3.使用vi.begin(),vi.end()即迭代器，作为算法的参数 4.使用count_if算法 5.使用仿函数less() 6.使用函数适配器来对我们算法的结果进行进一步筛选（not1, bind2nd） 2.复杂度 3.迭代器区间 迭代器是一个左开右闭的区间，也就是说迭代器的end是最后一个元素的下一个元素。 4.容器的结构和
序列式容器详解-stl源码剖析笔记
weixin_42853463的博客
06-24 311
public；//表示目前使用空间的头 iterator finish;//表示目前使用空间的尾 iterator end_of_storage;//表示目前可用空间的尾 void insert_aux(iterator position , const T & x);} public ://全局函数 deallocate();//vector的成员函数 } reference front() {
STL源码剖析.pdf
04-24
STL源码剖析.pdf
STL源码剖析.pdf(侯捷，完整版，已加全书签)
06-17
第4 章 序列式容器（sequence containers） 第5 章 關聯式容器（associated containers） 第6 章 演算法（algorithms） 第7 章 仿函式or 函式物件（functors, or function objects） 第8 章 配接器（adapter）
STL源码剖析pdf及源码.zip
06-25
侯捷书中提到的软件没必要安装，重要还是使用这些头文件，一个方便快捷的方式就是使用SourceInsight将这些头文件关联起来，使用起来方便。 书和源码一并找齐了。
STL源码剖析
04-21
学习编程的人都知道，阅读、剖析名家代码乃是提高水平的捷径。源码之前，了无秘密。大师们的缜密思维、经验结晶、技术思路、独到风格，都原原本本体现在源码之中。 这本书所呈现的源码，使读者看到vector的实现、...
C++基础——final 关键字
qw225967的博客
10-12 4570
  C++中，final关键字用于修饰类时，有以下作用：   1.禁止继承：c++11特性中，将类标记为final，意味着无法继承。 class test final { ...... };   2.禁止重写方法：当方法被标记为final时，在子类中无法重写该方法。 class test { public: test(); virtual void func() final; }; ...
C++基础——嵌套类
qw225967的博客
08-06 1139
C++基础——嵌套类 文章目录C++基础——嵌套类前言 前言    在一个类的内部定义另一个类，我们称之为嵌套类（nested class），或者嵌套类型。之所以引入这样一个嵌套类，往往是因为外围类需要使用嵌套类对象作为底层实现，并且该嵌套类只用于外围类的实现，且同时可以对用户隐藏该底层实现。    这个可以这样理解：有一些工作我们不想被用户知道怎么实现的，那么我们就把这些工作交给类内的嵌套类来实现，然后对我提供一个接口即可。 class A { class Imp; Imp* imp
C++基础——记一次双冒号(::)的使用
qw225967的博客
08-04 604
C++基础——记一次中双冒号(::)的使用 文章目录C++基础——记一次中双冒号(::)的使用前言 前言
C++基础——内联函数（转载）
qw225967的博客
08-09 192
C++基础——内联函数（转载） 文章目录C++基础——内联函数（转载）前言 前言    C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。    对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。    如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inli
STL源码剖析阅读笔记一（空间配置器）
qw225967的博客
05-01 145
空间配置器作为隐藏在一切组件背后的关键组件，是学习STL源码的重要内容。事实上allocator不应该称为空间配置器，而应该称为内存配置器。因为空间并不一定是内存，也可以是磁盘或者其他辅助存储介质。 //.h文件 #ifndef _JJALLOC_ #define _JJALLOC_ #include <new> #include <cstddef> #include &...
STL源码剖析阅读笔记二（迭代器）
qw225967的博客
08-09 129
前言
STL源码剖析阅读笔记三（序列容器vector）
qw225967的博客
11-08 119
一、概述   我们平时使用数组（array）时是不是经常因为扩容问题而头疼，其实vector与array之间多的就是空间配置的部分。本章序列容器的vector对array进行了空间管理的封装以及几种迭代器的封装，从而实现了我们所认识的第一个序列容器——vector。 二、定义式   代码示例： // alloc 是 SGI STL 的空間配置器，見第二章。 template <class T, class Alloc = alloc> class vector { public: // vect
数据结构与算法学习笔记七--二叉树(C++)
最新发布
我叫柱子哥
04-23 593
在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。根节点（Root）：树中的唯一顶层节点，没有父节点。
【C】 初识C语言
努力学习C/C++
04-21 739
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
侯捷stl源码剖析学习笔记
08-18
侯捷的《STL源码剖析》是一本关于STL（标准模板库）的学习笔记。这本书深入解析了STL的实现原理和设计思路，对于理解STL的内部机制和使用方法非常有帮助。这些学习笔记记录了作者在学习侯捷的《STL标准库和泛型编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值