【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…

动态规划之简单多状态

简单多状态 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实际上就是自定…

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() 函…

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

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

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

在当今快节奏的生活中&#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;每个层的输出

数学建模--Subplot绘图的Python实现

目录 1.Subplot函数简介 2.Subplot绘图范例1:绘制规则子图 3.Subplot绘图范例2:绘制不规则子图 4.Subplot绘图范例3:gridspec辅助实战1 5.Subplot绘图范例4:gridspec辅助实战2 1.Subplot函数简介 """ 最近在数学建模种需要绘制多张子图,发现对于subplot函…

QT文件对话框,将标签内容保存至指定文件

一、主要步骤 首先&#xff0c;通过getSaveFileName过去想要保存的文件路径及文件名&#xff0c;其次&#xff0c;通过QFile类实例化一个文件对象&#xff0c;再读取文本框中的内容&#xff0c;最后将读取到的内容写入到文件中&#xff0c;最后关闭文件。 1.txt即为完成上述操作…

laragon 为 php 安装 Xdebug 扩展

众所周知&#xff0c;php 自带的 var_dump() 输出格式很不直观 而 laragon 作为很好的 windos 下开发环境很受欢迎&#xff0c;本文就介绍如何快速为 laragon 的 php 安装 Xdebug&#xff0c;方便开发调试 一&#xff1a;启动开发环境&#xff0c;在任意可访问 php 页面中输出 …

蓝桥杯备赛(Day5)——二叉树

二叉树存储 普通做法,二叉树一个节点包括结点的数值以及指向左右子节点的指针 在class Node中 def __init__(self,s,l=None,r=None):self.val=Noneself.l=lself.r=r 在竞赛中,我们往往使用静态数组实现二叉树,定义一个大小为N的静态结构体数组,使用其来存储一棵二叉树。…

python 学习笔记(4)—— webdriver 自动化操作浏览器(基础操作)

安装 web driver&#xff1a; 使用 driver 前&#xff0c;需要下载与浏览器版本相对应的 driver。如要在 Chrome 浏览器上操作&#xff0c;就要下载Chrome Driver。 几个常用浏览器的参考和下载地址&#xff1a; Edge Driver&#xff1a;https://developer.microsoft.com/en…

密码学入门——环游密码世界

文章目录 参考书目一、基本概念1.1 本书主要角色1.2 加密与解密 二、对称密码与公钥密码2.1 密钥2.2 对称密码和公钥密码2.3 混合密码技术 三、其他密码技术 参考书目 图解密码技术 第三版 一、基本概念 1.1 本书主要角色 1.2 加密与解密 加密 解密 密码破译 二、对称密…

Ansible之playbook详解和应用实例

目录 一、playbook简介 1.什么是playbook 2.playbook组成 二、应用实例 1.使用playbook安装启用httpd服务 2.使用playbook安装启用nginx服务 三、ansible-playbook其他用法 1.检查yaml文件的语法是否正确 2.检查tasks任务 3.检查指定的主机 4.指定从某个task开始运行…