【C++杂货铺】探索list的底层实现

在这里插入图片描述

文章目录

  • 一、list的介绍及使用
    • 1.1 list的介绍
    • 1.2 list的使用
      • 1.2.1 list的构造
      • 1.2.2 list iterator的使用
      • 1.2.3 list capacity(容量相关)
      • 1.2.4 list element access(元素访问)
      • 1.2.5 list modifiers(链表修改)
      • 1.2.6 list operation(对链表的一些操作)
  • 二、list的模拟实现
    • 2.1 list的节点
    • 2.2 list的成员变量
    • 2.3 list的迭代器
      • 2.3.1 普通迭代器
      • 2.3.2 const 迭代器
    • 2.4 list的成员函数
      • 2.4.1 构造函数
      • 2.4.2 拷贝构造函数
      • 2.4.3 赋值运算符重载
      • 2.4.4 push_back
      • 2.4.5 迭代器相关
      • 2.4.6 insert
      • 2.4.7 erase
      • 2.4.8 push_front
      • 2.4.9 pop_back
      • 2.4.10 pop_front
      • 2.4.11 size
      • 2.4.12 clear
      • 2.4.13 析构函数
  • 三、结语

一、list的介绍及使用

1.1 list的介绍

  • list 是可以在常数范围内在任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代。

  • list 的底层是双向链表结构,双向链表中的每个元素存储在互不相关的独立节点中,在节点中通过指针指向的前一个元素和后一个元素。

  • list 和 forward_list 非常相似:最主要的不同在于 forward_list 是单链表,只能朝前迭代,已让其更简单高效。

  • 与其它的序列式容器相比(arry、vector、deque),list 通常在任意位置进行插入,移除元素的执行效率更好。

  • 与其它序列式容器相比,list 和 forward_list 最大的缺陷是不支持任意位置的随机访问,比如:要访问 list 的第 5 个元素,必须从已知的位置(比如头部或者尾部)迭代到该位置,在这段位置上迭代需要线性的时间开销;list 还需要一些额外的空间,已保存每个节点的相关联信息。

1.2 list的使用

list 学习时一定要学会查看文档:list的文档介绍,list 在实际中非常重要,在实际中我们熟悉常用的接口就可以,下面列出了需要我们重点掌握的接口。

1.2.1 list的构造

构造函数接口说明
list()list 的默认构造,构造空的 list
list(size_type n, const value_type& val = value_type())构造的 list 中包含 n 个值为 val 的元素
list(const list& x)拷贝构造函数
list(InputIterator first, InputIterator last)用[first,last)区间中的元素构造 list

小Tips:size_type 表示一个无符号整数类型,value_type 是 list 的第一个模板参数,也就是要存储的数据类型。使用迭代器区间的构造函数是函数模板,只要是满足 Input 类型的迭代器都可以使用该构造函数。

void TestList1()
{list<int> l1;                         // 构造空的l1list<int> l2(4, 100);                 // l2中放4个值为100的元素list<int> l3(l2.begin(), l2.end());  // 用l2的[begin(), end())左闭右开的区间构造l3list<int> l4(l3);                    // 用l3拷贝构造l4// 以数组为迭代器区间构造l5int array[] = { 16,2,77,29 };list<int> l5(array, array + sizeof(array) / sizeof(int));// 列表格式初始化C++11list<int> l6{ 1,2,3,4,5 };// 用迭代器方式打印l5中的元素list<int>::iterator it = l5.begin();while (it != l5.end()){cout << *it << " ";++it;}cout << endl;// C++11范围for的方式遍历for (auto& e : l5)cout << e << " ";cout << endl;
}

1.2.2 list iterator的使用

此处,大家可暂时将迭代器理解成一个像指针一样的东西,该指针指向 list 中的某个节点。

函数声明接口说明
begin() + end()返回第一个元素的迭代器 + 返回最后一个元素下一个位置的迭代器
rebegin() + ren()返回第一个元素的 reverse_iterator,即 end 位置,返回最后一个一个元素下一个位置的 reverse_iterator,即 begin 位置

注意:begin 与 end 为正向迭代器,对迭代器执行 ++ 操作,迭代器向后移动。rbegin 与 rend 为反向迭代器,对迭代器执行 ++ 操作,迭代器向前移动。由于 list 的底层物理空间并不连续,所以 list 的迭代器不再是原生指针,并且 list 的迭代器没有对 + 和 - 进行重载,只重载了 ++ 和 – ,因为空间不连续,重载 + 会比较复杂。即 l.begin() + 5 是不被允许的。

void PrintList(const list<int>& l)
{// 注意这里调用的是list的 begin() const,返回list的const_iterator对象for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it){cout << *it << " ";// *it = 10; 编译不通过}cout << endl;
}void TestList2()
{int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };list<int> l(array, array + sizeof(array) / sizeof(array[0]));// 使用正向迭代器正向list中的元素// list<int>::iterator it = l.begin();   // C++98中语法auto it = l.begin();                     // C++11之后推荐写法while (it != l.end()){cout << *it << " ";++it;}cout << endl;// 使用反向迭代器逆向打印list中的元素// list<int>::reverse_iterator rit = l.rbegin();auto rit = l.rbegin();while (rit != l.rend()){cout << *rit << " ";++rit;}cout << endl;
}

注意:遍历链表只能使用迭代器和范围 for。

1.2.3 list capacity(容量相关)

函数声明接口说明
empty检测 list 是否为空,是返回 true,否则返回 false
size返回 list 中有效节点个数

1.2.4 list element access(元素访问)

函数声明接口说明
front返回 list 的第一个节点中值的引用
back返回 list 的最后一个节点中值的引用

1.2.5 list modifiers(链表修改)

函数声明接口说明
push_front在 list 的第一个节点前插入值为 val 的节点
pop_front删除 list 中第一个节点
push_back在 list 尾部插入一个值为 val 的节点
pop_back删除 list 中最后一个节点
insert在 list 的 position 位置中插入一个值为 val 的节点
erase删除 list position 位置的节点
swap交换两个 list 的节点
clear清空 list 中的有效元素

小Tips:insert 插入元素并不会导致迭代器失效,例如:相较于 vector 中的 insert,list 中的 insert 并不会去扩容挪动数据,而 vector 中的 insert 可能会进行扩容挪动数据,最终导致迭代器失效。list 中的删除元素接口会导致迭代器失效,失效的只有指向被删除节点的迭代器,其他迭代器不会受到影响。

1.2.6 list operation(对链表的一些操作)

函数声明接口说明
reverse对链表进行逆置
sort对链表中的元素进行排序(稳定排序)
merge对两个有序的链表进行归并,得到一个有序的链表
unique对链表中的元素去重
remove删除具有特定值的节点
splice将 A 链表中的节点转移到 B 链表

小Tips:链表逆置可以使用 list 自身的接口,也可以使用算法库中的 reverse,二者没有什么区别。链表排序只能使用 list 自身的 sort() 接口(底层是利用归并排序),不能使用算法库的 sort,因为算法库中的 sort 底层是通过快排来实现的,而快排中会涉及到三数取中需要迭代器 - 迭代器,链表不能很好的支持。虽然链表提供了排序接口,但是用链表对数据排序意义不大,效率太低了,更希望用 vector 来对数据进行排序。

void TestSort()
{srand(time(0));const int N = 5000000;vector<int> v;list<int> l;v.reserve(N);//提前开好空间for (int i = 0; i < N; i++){auto e = rand();v.push_back(e);l.push_back(e);}//开始比较vector 和 list 的排序int begin1 = clock();sort(v.begin(), v.end());int end1 = clock();int begin2 = clock();l.sort();int end2 = clock();printf("vector sort:%d\n", end1 - begin1);printf("list sort:%d\n", end2 - begin2);
}

在这里插入图片描述

扩展:可以从功能角度对迭代器分为以下 3 类:

迭代器类型功能
单向(InputIterator)支持 ++
双向(BidirectionalItreator)支持 ++/- -
随机(RandomAccessIterator)支持 ++ / - - / + / -

其中 forward_listunordered_xxx 都是单向迭代器;listmapset 都是双向迭代器;vectorstringdeque 都是随机迭代器。对迭代器的这种分类方式,是由容器的底层结构来决定的。

二、list的模拟实现

2.1 list的节点

template<class T>
struct ListNode
{ListNode<T>* _next;ListNode<T>* _prev;T _val;ListNode(const T& val = T()){_next = nullptr;_prev = nullptr;_val = val;}
};

2.2 list的成员变量

class list
{typedef ListNode<T> Node;
public://一些成员函数
private:Node* _head;
}

小Tips:typedef 会受到访问限定符的限制,这里没写默认是 private,意味着 Node 这个类型只能在 list 这个类里面使用。链表本质上是一种数据结构,我们只需要维护好一个链表的头节点即可,所以 list 的成员变量就只有一个头节点的指针。

2.3 list的迭代器

list 的迭代器不能再使用原生指针,如果 list 的迭代器使用原生指针的话,那对迭代器解引用得到的是一个节点,而我们希望对迭代器解引用可以得到节点里面存储的元素,并且 list 在底层的物理空间并不连续,如果使用原生指针作为 list 的迭代器,那对迭代器执行 ++ 操作,并不会让迭代器指向下一个节点。因此我们需要对 list 的迭代器进行封装,然后将一些运算符进行重载,以实现迭代器本该有的效果。

2.3.1 普通迭代器

template<class T>
struct _list_iterator
{typedef ListNode<T> Node;Node* _node;_list_iterator(Node* val){_node = val;}T& operator* (){return _node->_val;}T* operator-> ()//迭代器通过->应该指向节点中的元素,因此返回的是一个T类型的地址{return &(_node->_val);}bool operator!= (const _list_iterator<T>& right){return _node != right._node;}_list_iterator<T> operator++(){_node = _node->_next;return *this;}_list_iterator<T> operator++(int){_list_iterator<T> tmp(this->_node);_node = _node->_next;return tmp;}
};

小Tips:这里的类名不能直接叫 iterator,因为每种容器的迭代器底层实现可能都有所不同,即可能会为每一种容器都单独实现一个迭代器类,如果都直接使用 iterator,会导致命名冲突。其次,迭代器类不需要我们自己写析构函数、拷贝构造函数、赋值运算符重载函数,直接使用默认生成的就可以,言外之意就是这里使用浅拷贝即可,因为迭代器只是一种工具,它不需要对资源进行释放清理,资源释放清理工作是在容器类中实现的,浅拷贝的问题就出在会对同一块空间释放两次,而迭代器无需对空间进行释放,所以浅拷贝是满足我们需求的。

2.3.2 const 迭代器

上面我们实现了普通迭代器,那 const 迭代器该如何实现呢?直接在容器类里面写上一句 typedef const _list_iterator<T> const_iterator 可以嘛?答案是不可以,const 迭代器本质是限制迭代器指向的内容不能修改,而 const 迭代器自身可以修改,它可以指向其他节点。前面这种写法,const 限制的就是迭代器本身,会让迭代器无法实现 ++ 等操作。那如何控制迭代指向的内容不能修改呢?可以通过控制 operator* 的返回值来实现。但是仅仅只有返回值类型不同,是无法构成函数重载的。那要怎样才能在一个类里面实现两个 operator* 让他俩一个返回普通的 T&,一个返回 const T& 呢?一般人可能想着那就再单独写一个 _list_const_iterator 的类,这样也行,就是会比较冗余,我们可以通过在普通迭代器的基础上,再传递一个模板参数,让编译器来帮们生成呀。除此之外, operator->也需要实现 const 版本,因此还需要第三个模板参数。

template<class T,class Ref, class Ptr>
struct _list_iterator
{typedef ListNode<T> Node;typedef _list_iterator<T, Ref, Ptr> self;Node* _node;_list_iterator(Node* val){_node = val;}Ref operator* (){return _node->_val;}Ptr operator-> (){return &(_node->_val);}bool operator!= (const self& right) const{return _node != right._node;}bool operator== (const self& right) const{return _node == right._node;}self operator++(){_node = _node->_next;return *this;}self operator++(int){self tmp(this->_node);_node = _node->_next;return tmp;}self operator--(){_node = _node->_prev;return *this;}self operator--(int){self tmp(*this);_node = _node->_prev;return tmp;}
};
//operator->的使用场景
struct A
{A(int a = 0, int b = 0){_a = a;_b = b;}int _a;int _b;
};void Textlist3()
{wcy::list<A> l;l.push_back(A(1, 2));l.push_back(A(3, 4));l.push_back(A(5, 6));l.push_back(A(7, 8));wcy::list<A>::iterator it = l.begin();while (it != l.end()){cout << it->_a << ',' << it->_b << " ";cout << endl;it++;}
}

小Tips:上面代码中的 it->_a 会去调用 operator->,返回一个 A 类型的指针,所以这里应该是两个 ->,即 it->->_a ,但是编译器进行了优化,只需要一个 -> 即可。

2.4 list的成员函数

2.4.1 构造函数

list()
{_head = new Node;_head->_prev = _head;_head->_next = _next;
}

小Tips:list 本质上是一个带头双向循环链表。

2.4.2 拷贝构造函数

list(const list& ll)
//list(const list<T>& ll)
{_head = new Node;_head->_prev = _head;_head->_next = _head;for (auto& e : ll){push_back(e);}
}

2.4.3 赋值运算符重载

void swap(list<T> l2)
{std::swap(_head, l2._head);
}list& operator=(const list ll)
//list<T>& operator=(const list<T> ll)
{//现代写法swap(ll);return *this;
}

小Tips:构造函数和赋值运算符重载函数的形参和返回值类型可以只写类名 list,无需写完整的类型 list<T>,但是不推荐这样写,容易造成混淆,其次现代写法和常规写法在效率上没有任何区别,只是将本来需要我们做的事情交给了编译器去做。

2.4.4 push_back

void push_back(const T& val)
{//先找尾Node* tail = _head;while (tail->_next != _head){tail = tail->_next;}//插入元素Node* newnode = new Node(val);tail->_next = newnode;newnode->_prev = tail;newnode->_next = _head;_head->_prev = newnode;
}

2.4.5 迭代器相关

iterator begin()
{return _head->_next;//单参数的构造函数支持隐式类型转换
}iterator end()
{return _head;
}const_iterator begin() const
{return _head->_next;//单参数的构造函数支持隐式类型转换
}const_iterator end() const
{return _head;
}

2.4.6 insert

iterator insert(iterator pos, const T& val)
{//找到 pos 位置的前一个位置Node* cur = pos._node;Node* prev = cur->_prev;//插入元素Node* newnode = new Node(val);prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return newnode;
}

2.4.7 erase

iterator erase(iterator pos)
{assert(pos != end());Node* cur = pos._node;//保存当前节点Node* prev = cur->_prev;//保存前一个节点Node* next = cur->_next;//保存后一个节点prev->_next = next;next->_prev = prev;delete cur;cur = nullptr;return next;
}

2.4.8 push_front

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

2.4.9 pop_back

void pop_back()
{erase(--end());
}

2.4.10 pop_front

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

2.4.11 size

size_t size()
{size_t sz = 0;iterator it = begin();while (it != end()){it++;sz++;}return sz;
}

2.4.12 clear

void clear()
{iterator it = begin();while (it != end()){it = erase(it);}
}

2.4.13 析构函数

~list()
{clear();delete _head;_head = nullptr;
}

小Tips:clear 和 析构函数的主要区别在于是否释放头节点。

三、结语

今天的分享到这里就结束啦!如果觉得文章还不错的话,可以三连支持一下,春人的主页还有很多有趣的文章,欢迎小伙伴们前去点评,您的支持就是春人前进的动力!

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/69873.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

anaconda navigator打不开,一直在loading画面

anaconda navigator打不开&#xff0c;一直在loading画面。百度解决方法&#xff0c;用网上的方法在命令窗口里运行conda update anaconda结果一直显示 solving environment卡在那里。又尝试用管理员身份运行还是不行&#xff0c;打开后出现There in aninstance of Anaconda Na…

C标准输入与标准输出——stdin,stdout

&#x1f517; 《C语言趣味教程》&#x1f448; 猛戳订阅&#xff01;&#xff01;&#xff01; ​—— 热门专栏《维生素C语言》的重制版 —— &#x1f4ad; 写在前面&#xff1a;这是一套 C 语言趣味教学专栏&#xff0c;目前正在火热连载中&#xff0c;欢迎猛戳订阅&#…

iOS系统下轻松构建自动化数据收集流程

在当今信息爆炸的时代&#xff0c;我们经常需要从各种渠道获取大量的数据。然而&#xff0c;手动收集这些数据不仅耗费时间和精力&#xff0c;还容易出错。幸运的是&#xff0c;在现代科技发展中有两个强大工具可以帮助我们解决这一问题——Python编程语言和iOS设备上预装的Sho…

ref、$ref $nextTick

ref和$refs 1.作用 利用ref 和 $refs 可以用于 获取 dom 元素 或 组件实例 2.特点&#xff1a; 查找范围 → 当前组件内(更精确稳定) 3.语法 1.给要获取的盒子添加ref属性 <div ref"chartRef">我是渲染图表的容器</div> 2.获取时通过 $refs获取 …

动态规划之简单多状态

简单多状态 1. 按摩师&#xff08;easy&#xff09;2. 打家劫舍II &#xff08;medium&#xff09;3. 删除并获得点数&#xff08;medium&#xff09;4. 买卖股票的最佳时机含冷冻期&#xff08;medium&#xff09;5. 买卖股票的最佳时机III&#xff08;hard&#xff09; 1. 按…

c++(c语言)通用版本的单链表的头插法创建

我们创建一个长度为n的链表时&#xff0c;可以采取头插法创建或者尾插法创建&#xff0c;本篇博客我们采取头插法来创建&#xff0c;&#xff08;作者只学了头插&#xff0c;尾插等以后来补qwq)。 我们先来画图来看看头插的创建形式把&#xff0c;会了原理再写代码。 首先是我…

自定义TimeLine实现卡拉OK轨

系列文章目录 自定义TimeLine 自定义TimeLine 系列文章目录前言正文UI部分代码部分Data&#xff08;数据&#xff09;Clip&#xff08;片段&#xff09;Track&#xff08;轨道&#xff09;Mixer&#xff08;混合&#xff09;被控制物体 总结 前言 自定义TimeLine实际上就是自定…

Javascript笔记

for…in for…in 循环用于遍历对象属性&#xff08;自身的原型链上的&#xff09; const person {name: Alice,age: 25,occupation: Engineer };for (const key in person) {console.log(key, person[key]); // 输出属性名和属性值 }只遍历对象自身的属性&#xff0c;而不包…

Redis缓存的高并发问题

Redis 做缓存虽减轻了 DBMS 的压力&#xff0c;减小了 RT&#xff0c;但在高并发情况下也是可能会出现各 种问题的。 1 缓存穿透 当用户访问的数据既不在缓存也不在数据库中时&#xff0c;就会导致每个用户查询都会“穿透” 缓存“直抵”数据库。这种情况就称为缓存穿透。一个…

OpenCV(十):图像缩放、翻转、拼接的介绍与使用

目录 &#xff08;1&#xff09;图像缩放&#xff1a;resize() &#xff08;2&#xff09;图像翻转&#xff1a; flip() &#xff08;3&#xff09;图像拼接&#xff1a;hconcat() 和vconcat() &#xff08;1&#xff09;图像缩放&#xff1a;resize() 使用 cv2.resize() 函…

clickhouse调优配置

一、官方文档地址 clickhouse的配置项主要在 config.xml 或 users.xml 中&#xff0c; 基本上都在 users.xml 里 config.xml https://clickhouse.tech/docs/en/operations/server-configuration-parameters/settings/ users.xml https://clickhouse.tech/docs/en/operatio…

sql:SQL优化知识点记录(十一)

&#xff08;1&#xff09;用Show Profile进行sql分析 新的一个优化的方式show Profile 运行一些查询sql&#xff1a; 查看一下我们执行过的sql 显示sql查询声明周期完整的过程&#xff1a; 当执行过程出现了下面这4个中的时&#xff0c;就会有问题导致效率慢 8这个sql创建…

算法训练营第四十一天(9.2)| 动态规划Part11:最长公共子序列

Leecode 1143.最长公共子序列 题目地址&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 题目类型&#xff1a;最长子序列 class Solution { public:int longestCommonSubsequence(string text1, string text2) {int m text1.size(), n t…

搬家快递服务小程序的便利性

在当今快节奏的生活中&#xff0c;搬家可能是很多人都需要面对的问题。无论是新房子还是新办公室&#xff0c;都需要高效、便捷的搬家服务。本文将介绍如何使用第三方小程序制作平台&#xff0c;如乔拓云平台&#xff0c;开发一款高效便捷的搬家服务小程序。 1. 注册登录第三方…

【易售小程序项目】修改“我的”界面前端实现;查看、重新编辑、下架自己发布的商品【后端基于若依管理系统开发】

文章目录 “我的”界面修改效果界面实现界面整体代码 查看已发布商品界面效果商品数据表后端上架、下架商品ControllerMapper 界面整体代码back方法 编辑商品、商品发布、保存草稿后端商品校验方法Controller 页面整体代码 同项目其他文章 “我的”界面修改 效果 界面实现 界…

【C++设计模式】详解装饰模式

2023年8月31日&#xff0c;周四上午 这是我目前碰到的最难的设计模式..... 非常难以理解而且比较灵活多半&#xff0c;学得贼难受&#xff0c;写得贼费劲..... 2023年8月31日&#xff0c;周四晚上19:48 终于写完了&#xff0c;花了一天的时间来学习装饰模式和写这篇博客。 …

序列到序列学习(seq2seq)

permute(1,0,2)&#xff0c;将batch_size 放在中间state 最后一个时刻&#xff0c;每个层的输出

nginx的限速和限制并发连接数、限制请求数

nginx的限速和限制并发连接数、限制请求数 限速&#xff08;Rate Limiting&#xff09;&#xff1a; 限速允许你控制对服务器的请求速率&#xff0c;以防止过多的请求影响服务器性能。使用 limit_req_zone 指令定义一个共享内存区域&#xff0c;并在 location 块中使用 limit_r…

kafka学习

链接1&#xff1a;Kafka入门教程_香菜的博客-CSDN博客 链接2&#xff1a;https://mbd.baidu.com/ug_share/mbox/4a83aa9e65/share?productsmartapp&tkd716b5f663babe03088adca09b0fb938&share_urlhttps%3A%2F%2Fyebd1h.smartapps.cn%2Fpages%2Fblog%2Findex%3FblogId…

Golang字符串基本处理方法

Golang的字符串处理 字符串拼接 两种方法&#xff1a;strings.Join方法和’方法 ‘’方法 这种方式使用起来最简单&#xff0c;基本所有语言都有提供这种方式&#xff0c;使用 “” 操作符进行拼接时&#xff0c;会对字符串进行遍历&#xff0c;计算并开辟一个新的空间来存储…