list(模拟实现)

【STL】模拟实现list 因为迭代器·结点指针的行为不能满足迭代器定义,那么我们可以对这个结点指针进行封装,对结点指针的各种运算符进行重载,使得我们可以像使用string和vector当中的迭代器一样去使用list当中的迭代器。当我们使用解引用操作符时,是想得到该位置的数据内容,所以我们直接返回当前结点指针所指向的数据即可,但是这里需要解引用返回,得到数据之后,我们后面可能会对这个数据进行修改。对于后置--,我们需要记录结点指针当前的位置,让结点指针向指向前一个结点,然后返回自减前的结点指针即可。 阅读详情

目录

list概念

list的使用

list的构造

list iterator的使用

list capacity

list element access

list modifiers

list的迭代器失效

list的模拟实现

list与vector的对比


list概念

  • list是可以在常数范围内在任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代。
  • list的底层是双向链表结构,双向链表中每个元素存储在互不相关的独立节点中,在节点中通过指针指向其前一个元素和后一个元素。
  • list与forward_list非常相似:最主要的不同在于forward_list是单链表,只能朝前迭代,已让其更简单高效。
  • 与其他的序列式容器相比(array,vector,deque),list通常在任意位置进行插入、移除元素的执行效率更好。
  • 与其他序列式容器相比,list和forward_list最大的缺陷是不支持任意位置的随机访问,比如:要访问list的第6个元素,必须从已知的位置(比如头部或者尾部)迭代到该位置,在这段位置上迭代需要线性的时间开销;list还需要一些额外的空间,以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)

list的使用

list中的接口比较多,此处类似,只需要掌握如何正确的使用,然后再去深入研究背后的原理,已达到可扩展的能力。以下为list中一些常见的重要接口。

list的构造

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

list iterator的使用

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

注意:

  • 1. begin与end为正向迭代器,对迭代器执行++操作,迭代器向后移动
  • 2. rbegin(end)与rend(begin)为反向迭代器,对迭代器执行++操作,迭代器向前移动

list capacity

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

list element access

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

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中的有效元素

list的迭代器失效

此处大家可将迭代器暂时理解成类似于指针,迭代器失效即迭代器所指向的节点的无效,即该节点被删除了。因为list的底层结构为带头结点的双向循环链表,因此在list中进行插入时是不会导致list的迭代器失效的,只有在删除时才会失效,并且失效的只是指向被删除节点的迭代器,其他迭代器不会受到影响。

void TestListIterator1()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    list<int> l(array, array+sizeof(array)/sizeof(array[0]));
    auto it = l.begin();
    while (it != l.end())
    {
    // erase()函数执行后,it所指向的节点已被删除,因此it无效,在下一次使用it时,必须先给其赋值
        l.erase(it);
        ++it;
    }
}
// 改正
void TestListIterator()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    list<int> l(array, array+sizeof(array)/sizeof(array[0]));
    auto it = l.begin();
    while (it != l.end())
    {
        l.erase(it++); // it = l.erase(it);
    }
}

list的模拟实现

要模拟实现list,必须要熟悉list的底层结构以及其接口的含义,通过上面的学习,这些内容已基本掌握,现在我们来模拟实现list。

模拟实现list 

#pragma once

#include <assert.h>
#include<iostream>
#include "reverse_iterator.h"
using namespace std;

namespace chx
{
	template<typename T>
	struct list_node
	{
		T _data;
		list_node* _next;
		list_node* _prev;
		list_node(const T& x = T())
		:_data(x)
		,_next(nullptr)
		,_prev(nullptr)
		{}
	};
	template<class T,class Ptr,class Ref>
	struct _list_iterator
	{
		typedef list_node<T> Node;
		typedef _list_iterator<T, Ptr, Ref> iterator;
		Node* _node;
		_list_iterator(Node* node)
			:_node(node)
		{}
		bool operator==(iterator& it)const
		{
			return _node == it._node;
		}
		bool operator!=(iterator& it)const
		{
			return _node != it._node;
		}
		Ref operator*()
		{
			return _node->date;
		}
		Ptr operator->()
		{
			return &(operator*());
		}
		// ++it
		iterator& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		// it++
		iterator operator++(int)
		{
			iterator tmp(*this);
			_node = _node->_next;
			return tmp;
		}

		// --it
		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		// it--
		iterator operator--(int)
		{
			iterator tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
	};
	template<typename T>
	class list
	{
		typedef list_node<T> Node;
	public:
		//这一步就是对上面一个迭代器进行重命名
		//下面迭代器begin返回的就是构造的一个匿名对象,也就是调用上面迭代器的构造函数
		typedef _list_iterator<T, T&, T*> iterator;
		typedef _list_iterator<T, const T&, const T*> const_iterator;
		typedef __reverse_iterator<iterator, T&, T*> reverse_iterator;
		typedef __reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}

		const_iterator end() const
		{
			return const_iterator(_head);
		}

		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return iterator(_head);
		}
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
		list()
		{
			empty_init();
		}
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		template<class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			empty_init();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		void swap(list<T>& x)
			//void swap(list& x)
		{
			std::swap(_head, x._head);
		}

		// lt2(lt1)
		list(const list<T>& lt)
		{
			empty_init();
			list<T> tmp(lt.begin(), lt.end());
			swap(tmp);
		}

		// lt1 = lt3
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		void push_back(const T& x)
		{
			//Node* tail = _head->_prev;
			//Node* newnode = new Node(x);

			//// _head          tail  newnode
			//tail->_next = newnode;
			//newnode->_prev = tail;
			//newnode->_next = _head;
			//_head->_prev = newnode;

			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* tmp = new Node(x);
			prev->_next = tmp;
			tmp->_prev = prev;
			tmp->_next = cur;
			cur->_prev = tmp;
			return iterator(tmp);
		}
		void pop_back()
		{
			erase(--end());
		}

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

		iterator erase(iterator pos)
		{
			Node* cur = pos->_node;
			Node* prev = cur->_prev;
			Node* next = cur->_prev;
			next->_prev = prev;
			prev->_next = next;
			delete cur;
			return iterator(next);
		}
	private:
		Node* _head;
	};
}

list的反向迭代器

通过前面例子知道,反向迭代器的++就是正向迭代器的--,反向迭代器的--就是正向迭代器的++,因此反向迭代器的实现可以借助正向迭代器,即:反向迭代器内部可以包含一个正向迭代器,对正向迭代器的接口进行包装即可。

#pragma once

namespace chx
{
	template<class Iterator, class Ref, class Ptr>
	struct __reverse_iterator
	{
		Iterator _cur;
		typedef __reverse_iterator<Iterator, Ref, Ptr> RIterator;

		__reverse_iterator(Iterator it)
			:_cur(it)
		{}

		RIterator operator++()
		{
			--_cur;
			return *this;
		}

		RIterator operator--()
		{
			++_cur;
			return *this;
		}

		Ref operator*()
		{
			//return *_cur;
			auto tmp = _cur;
			--tmp;
			return *tmp;
		}

		Ptr operator->()
		{
			//return _cur.operator->();
			return &(operator*());
		}

		bool operator!=(const RIterator& it)
		{
			return _cur != it._cur;
		}
	};
}

list与vector的对比

vector与list都是STL中非常重要的序列式容器,由于两个容器的底层结构不同,导致其特性以及应用场景不同,其主要不同如下:

                vector与list的对比
底 层 结 构动态顺序表,一段连续空间带头结点的双向循环链表
随 机 访 问支持随机访问,访问某个元素效率O(1)不支持随机访问,访问某个元素
效率O(N)
插 入 和 删 除任意位置插入和删除效率低,需要搬移元素,时间复杂
度为O(N),插入时有可能需要增容,增容:开辟新空
间,拷贝元素,释放旧空间,导致效率更低
任意位置插入和删除效率高,不
需要搬移元素,时间复杂度为
O(1)
空 间 利 用 率底层为连续空间,不容易造成内存碎片,空间利用率
高,缓存利用率高
底层节点动态开辟,小节点容易
造成内存碎片,空间利用率低,
缓存利用率低
迭 代 器原生态指针对原生态指针(节点指针)进行封装
迭 代 器 失 效在插入元素时,要给所有的迭代器重新赋值,因为插入
元素有可能会导致重新扩容,致使原来迭代器失效,删
除时,当前迭代器需要重新赋值否则会失效
插入元素不会导致迭代器失效,
删除元素时,只会导致当前迭代
器失效,其他迭代器不受影响
使 用 场 景需要高效存储,支持随机访问,不关心插入删除效率大量插入和删除操作,不关心随
机访问
STL中list的模拟实现 list的模拟,list的迭代器,面向对象的三大特征 阅读详情

相关推荐

【C++STL基础入门】list基本使用

STL(Standard Template Library)是C++标准库的一个重要组成部分,提供了一套丰富的数据结构和算法,可以大大简化C++程序的开发过程。其中,list容器是STL提供的一种双向链表实现的数据结构,具有高效的插入和删除操作,适用于需要频繁插入和删除元素的场景。本文将介绍list容器的基本使用方法,包括头文件的引入、定义和构造函数、属性函数以及运算符和算法的示例代码。STL(标准模板库)的list是C++中的一种数据结构,用于存储和操作链表。

m0_62599305的博客 2262

STL——list详解

这是一片关于list的详细介绍,并模拟实现了一个list类,帮助您更深入地理解和使用STL

weixin_54209978的博客 5223

[华为ensp]双核心的园区网

(给部分只会emm......借鉴的朋友提个醒,在group-member e0/0/2 to e0/0/20是所选,所以到了p l t那会给2-20端口都配置上trunk,别紧张,不是你问题)完成上述配置后,PC1可以ping通HTTP2服务器,Client1可以访问HTTP2服务器的HTTP站点,如果不能就要检查上述是否正确。本次实验主要目的是采用双核心的冗余网络,采用MSTP和VRRP技术,在核心层交换机上配置SC1上配置OSPF协议。SC1交换机上配置VRRP。在SC1上配置DHCP。

2301_78859499的博客 1416

STL详解----list的使用

学习了vector与string我们可以知道,所谓的STL就是将字符串,数组等数据结构进行严密地封装,方便我们直接使用而不需要进行临时创建,本节将介绍STL中的list,该类是对双向带头循环链表的使用。

分享学习的知识,记录我的技术成长道路 9857

微机原理-基于8086电压报警2.5V仿真系统设计

*单片机设计介绍,微机原理-基于8086电压报警2.5V仿真系统设计。

2201_75940997的博客 1083

智能座舱语音测试避坑指南:从唤醒率到方言识别,这些场景你测全了吗?

本文深入解析智能座舱语音测试的关键场景与避坑指南,涵盖唤醒率测试、方言识别、多音区交互等复杂场景。通过实战案例与自动化测试方案,帮助开发者全面提升语音系统的可靠性与用户体验,特别关注环境噪声干扰与方言覆盖策略。

weixin_42613501的博客 501

STL--list容器(链表)

C++STL中list容器的介绍和使用说明,list相当于数据结构中的链表。

hjl011006的博客 4060

MIKE 21 教程 2.9 初始条件(Initial Conditions),边界条件Boundary Conditions),解耦(Decoupling)

本节讲解初始条件与边界条件的设置。这两个模块如设置有误则极易出现模型崩溃。

Hello Word 4802

STL详解 - list

list的介绍与使用

天行健、君子以自强不息 1341

c++对halcon的动态链接库dll封装及调用(细细讲)

本文详细介绍了将Halcon图像处理算法封装为C++动态链接库(DLL)的完整流程,包括7个关键步骤:1)封装Halcon函数并导出CPP文件;2)在C++项目中配置Halcon环境(包含目录、库目录设置);3)验证Halcon代码;4)创建DLL项目并进行环境配置;5)编辑DLL并导出生成文件(.dll、.lib、.h);6)在主项目中配置DLL调用环境;7)编写测试代码验证功能。通过这个流程实现了Halcon算法的模块化封装和复用,文中提供了具体的配置路径和代码示例,重点说明了环境配置细节和文件结构安排

Tianwen_running的博客 969

YOLOv8 Neck改进:BiFPN双向特征金字塔网络解析与实践

本文详细介绍了如何在YOLOv8中集成BiFPN双向特征金字塔网络,包括原理解析、代码实现、配置文件修改和性能分析。BiFPN通过双向特征融合和加权特征机制,显著提升了多尺度目标检测的性能。希望通过本文的讲解,大家能够深入理解BiFPN的工作原理,并成功将其应用到自己的目标检测项目中。如果你有任何问题或建议,欢迎在评论区留言讨论!在下一篇文章中,我们将探讨YOLOv8的其他改进技术,包括注意力机制、新的损失函数等,敬请期待!

QQ_778132974的博客 993

【C++】list的模拟实现

list是带头双向循环链表,与vector的底层结构不一样,vector是连续的空间,list的每个节点是独立的空间。struct ListNode//节点类struct ListIterator//正向迭代器类struct ReverseIterator//反向迭代器类class list//模拟实现list类//获取第一个节点数据T& front()//获取最后一个节点数据T& back()

2301_77459845的博客 1658

部署OpenClaw时设置环境变量提示export: not valid in this context的完整解决方案

OpenClaw环境变量设置错误解决方案 问题概述 在部署OpenClaw时设置环境变量出现"export: not valid in this context"错误,通常由以下原因导致: 在非交互式shell中使用export命令 在命令替换或管道中使用export 脚本文件包含Windows换行符(CRLF) 解决方案 修正脚本执行方式:确保export命令在正确的shell上下文中使用 使用source命令:通过. setup_openclaw.sh或source setup_op

博客 459

C++《list的模拟实现》

在上一篇C++《list》专题当中我们了解了STL当中list类当中的各个成员函数该如何使用,接下来在本篇当中我们将试着模拟实现list,在本篇当中我们将通过模拟实现list过程中深入理解list迭代器和之前学习的vector和string迭代器的不同,接下来就开始本篇的·学习吧!

mljy.博客 3579

uni-app - 解决 H5 微信公众号授权登录后,无法回退到 “上一页“ 的问题(微信登录后如何返回到触发它的那一页?无法通过 uni.navigateBack() 返回到前一页的问题?)详细教程

uniappH5微信登录重定向后无法返回到原来进入前的页面了,uni-appH5微信浏览器中授权微信登录后,无法正常回退问题,uniappH5微信登录后怎么返回上一页,uniapp公众号登陆后使用uni.navigateBack()回不去上一页,uniapp微信登录成功后返回页面后一直自动刷新页面,uniapph5授权成功后如何返回上一页,uniappH5微信登录后怎么返回到触发它的那一页去,公众号h5在授权后如何跳转回到刚进入时的页面,微信公众号H5网页返回上一页疑问,解决微信H5静默授

🏆 前端领域优质创作者 7716

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

list的模拟实现

本文模拟实现了list,充分体现了模版的重要性,重点理解普通迭代器和const迭代器的区别。

adcxhw的博客 881

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

C++ list模拟实现

C++ list模拟实现

Wzs040810的博客 2529

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

【C++】list 模拟实现

list的模拟实现

f_2789889770的博客 1864

【C++】list模拟实现

本篇博客主要内容:STL库中list的模拟实现。实现list就和之前的vector和string大不相同了,vector和string的底层结构是顺序表,而list的底层是链表,学习list初阶数据结构-顺序表和链表(C语言)本篇的list实现中,迭代器的实现是重难点,它不再和以前的实现一样,只是单纯的原生指针,而是一个迭代器模板类。希望大家在了解list迭代器的实现之后,能对STL库中容器的迭代器有着更深的认识。

2303_79329831的博客 3291

C++ list的模拟实现

本文详细解析了C++中list容器的模拟实现,重点介绍了带头双向循环链表的结构设计和迭代器实现。主要内容包括: 链表节点设计:采用模板类__list_node包含prev、next指针和数据域,支持默认构造和灵活初始化; 哨兵节点机制:通过不存储数据的哨兵头节点简化边界操作,形成循环链表结构; 迭代器实现:封装节点指针,重载操作符模拟指针行为,通过模板参数区分普通迭代器和const迭代器; 核心接口实现:包括push_back、insert、erase等操作,以及现代写法实现的拷贝构造和赋值重载。 该实现完

2401_88465894的博客 1249

list模拟实现

文章目录一. list接口函数总览二.结点类的模拟实现三. 迭代器类模拟实现构造函数前置++和后置++前置- -和后置- -==/!=运算符重载* 运算符重载-> 运算符重载list模拟实现构造函数拷贝构造函数赋值运算符重载析构函数begin和endfront/backinserterasepush_back/pop_back/push_front/pop_frontsizeclearemptyswapresize 一. list接口函数总览 namespace lyp { //模拟实现list当中

DR5200的博客 1066

STL:List的使用和模拟实现

而earse必然会失效,因为该迭代器对应的节点被删除了。如果我们想继续用的话,就得利用返回值去更新迭代器,返回值是被删除元素的下一个位置的迭代器。

weixin_51142926的博客 3860

【C++】STL——list的模拟实现

本文主要讲述了list的模拟实现

2301_77112794的博客 1162

【STL】list模拟实现

stl_list模拟实现

m0_70088010的博客 1945
上一篇: vector模拟实现
下一篇: start&&queue(模拟实现及底层原理)
pythoncjavac++
博客等级 码龄5年 718粉丝 71原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

pythoncjavac++

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值