C++：list使用以及模拟实现

news2024/11/22 16:16:16

list使用以及模拟实现

    • list介绍
    • list常用接口
      • 1.构造
      • 2.迭代器
      • 3.容量
      • 4.访问数据
      • 5.增删查改
      • 6.迭代器失效
    • list模拟实现
      • 1.迭代器的实现
      • 2.完整代码

list介绍

  1. list是一个类模板，加<类型>实例化才是具体的类。
  2. list是可以在任意位置进行插入和删除的序列式容器。
  3. list的底层是双向循环链表结构，链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
  4. 与其他序列式容器相比，list最大的缺陷是不支持任意位置的随机访问，比如访问第六个节点，必须从已知节点迭代到该节点。

双向链表图解：
双向链表图解



list常用接口

1.构造

函数功能
list (size_type n, const value_type& val = value_type())构造的list中包含n个值为val的节点
list()构造空的list
list (const list& x)拷贝构造
list (InputIterator first, InputIterator last)迭代器区间初始化
(模板，可以传入其它容器的迭代器区间)

2.迭代器

函数功能
begin()加end()获取第一个数据位置的iterator/const_iterator，获取最后一个数据的下一个位置的iterator/const_iterator
rbegin()加rend()反向迭代器，获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator

3.容量

函数功能
size()获取有效数据个数
empty()判断是否为空(size为0为空，返回true)

4.访问数据

函数功能
front()取到头节点数据的引用
back()返回尾节点数据的引用

5.增删查改

函数功能
push_front
(const value_type& val)		头插数据val
push_back
(const value_type& val)		尾删数据val
pop_front()头删
pop_back()尾删
insert (iterator position, const value_type& val)在position位置中插入值为val的元素
erase (iterator position)删除position位置的元素
swap(list& x)交换两个list
clear()清空有效数据

6.迭代器失效

       迭代失效即迭代器所指向的节点的无效，即该节点被删除了。 因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

#include<iostream>
#include<list>
using namespace std;

//错误代码演示
int main()
{
	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时，必须先给其赋值
		it = l.erase(it); //只需要去掉++it,这里修改成it = erase(it)即可
		++it;
	}
	return 0;
}



list模拟实现

1.迭代器的实现

      有别于vector，list的迭代器并不是一个原生的指针，因为使用者需要得到的是节点中的数据而不是整个节点，而且寻找下一个节点并不能通过指针简单的++，所以需要把迭代器单独封装成一个类，通过重载*等运算符来完成需求。

namespace MyList
{
	//节点设计成结构体,方便访问
	template<typename T>
	struct list_node
	{
		list_node(const T val = T())
			:_data(val)
			, _next(nullptr)
			, _prev(nullptr)
		{}
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;
	};

	//迭代器
	//这里设计模板参数除了迭代器，还有Ref(引用)和Ptr(指针)
	//这样设计是为了同时生成普通迭代器和const对象的迭代器
	//普通对象（可读可写）：iterator<T, T&, T*>
	//const对象（可读不可写）：const_iterator<T, const T&, const T*>
	template<typename T, typename Ref, typename Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self; //要返回迭代器需要返回实例化对象，重命名一下

		Node* _node;

		__list_iterator(Node* p)
			:_node(p)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		
		//后置++
		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

		Ref operator*()
		{
			return _node->_data;
		}

		//返回指针可以让自定义类型自行打印，访问成员
		//->操作符，比较特殊，it->_num转换出来其实是it.operator->()->_num
		Ptr operator->()
		{
			return &(_node->_data);
		}

		bool operator!=(const self& s)
		{
			return _node != s._node;
		}

		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};

	//反向迭代器
	//反向迭代器需要进行封装，其实就是复用普通迭代器，然后++和--操作反过来
	
	//普通对象（可读可写）：Reverse_iterator<iterator，T&，T*>
	//const对象（可读不可写）：Reverse_iterator<const_iterator，const T&，const T*>
	template<class Iterator, class Ref, class Ptr>
	struct Reverse_iterator
	{
		typedef Reverse_iterator<Iterator, Ref, Ptr> self;
		Iterator _it;

		//构造
		Reverse_iterator(Iterator it)
			:_it(it)
		{}


		self& operator++()
		{
			_it--;
			return *this;
		}


		self operator++(int)
		{
			self tmp(*this);
			_it--;
			return tmp;
		}


		self& operator--()
		{
			_it++;
			return *this;
		}


		self operator--(int)
		{
			self tmp(*this);
			_it++;
			return tmp;
		}


		Ref operator*()
		{
			return *_it;
		}


		Ptr operator->()
		{
			return _it;
		}


		bool operator!=(const self& s)
		{
			return _it != s._it;
		}


		bool operator==(const self& s)
		{
			return _it == s._it;
		}
	};
}

2.完整代码

#pragma once
#include<iostream>
using namespace std;

namespace MyList
{
	//节点设计成结构体,方便访问
	template<typename T>
	struct list_node
	{
		list_node(const T val = T())
			:_data(val)
			, _next(nullptr)
			, _prev(nullptr)
		{}
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;
	};

	//迭代器
	//这里设计模板参数除了迭代器，还有Ref(引用)和Ptr(指针)
	//这样设计是为了同时生成普通迭代器和const对象的迭代器
	//普通对象（可读可写）：iterator<T, T&, T*>
	//const对象（可读不可写）：const_iterator<T, const T&, const T*>
	template<typename T, typename Ref, typename Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self; //要返回迭代器需要返回实例化对象，重命名一下

		Node* _node;

		__list_iterator(Node* p)
			:_node(p)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

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

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

		Ref operator*()
		{
			return _node->_data;
		}

		//返回指针可以让自定义类型自行打印，访问成员
		//->操作符，比较特殊，it->_num转换出来其实是it.operator->()->_num
		Ptr operator->()
		{
			return &(_node->_data);
		}

		bool operator!=(const self& s)
		{
			return _node != s._node;
		}

		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};

	//反向迭代器
	//反向迭代器需要进行封装，其实就是复用普通迭代器，然后++和--操作反过来
	
	//普通对象（可读可写）：Reverse_iterator<iterator，T&，T*>
	//const对象（可读不可写）：Reverse_iterator<const_iterator，const T&，const T*>
	template<class Iterator, class Ref, class Ptr>
	struct Reverse_iterator
	{
		typedef Reverse_iterator<Iterator, Ref, Ptr> self;
		Iterator _it;


		Reverse_iterator(Iterator it)
			:_it(it)
		{}


		self& operator++()
		{
			_it--;
			return *this;
		}


		self operator++(int)
		{
			self tmp(*this);
			_it--;
			return tmp;
		}


		self& operator--()
		{
			_it++;
			return *this;
		}


		self operator--(int)
		{
			self tmp(*this);
			_it++;
			return tmp;
		}


		Ref operator*()
		{
			return *_it;
		}


		Ptr operator->()
		{
			return _it;
		}


		bool operator!=(const self& s)
		{
			return _it != s._it;
		}


		bool operator==(const self& s)
		{
			return _it == s._it;
		}
	};

	template<typename T>
	class list
	{
		typedef list_node<T> Node;

	public:
		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*> reverse_const_iterator;


		//迭代器部分
		iterator begin()
		{
			return _head->_next;
		}

		iterator end()
		{
			return _head;
		}

		const_iterator begin()const
		{
			return _head->_next;
		}

		const_iterator end()const
		{
			return _head;
		}

		reverse_iterator rbegin()
		{
			return (--end());//_head->_prev
		}

		reverse_iterator rend()
		{
			return (end());//_head
		}

		reverse_const_iterator rbegin()const
		{
			return (--end());//_head->_prev
		}

		reverse_const_iterator rend()const
		{
			return (end());//_head
		}

		/// //
		/// 
	private:
		//不希望外界调用，设计成私有
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
	public:
		//构造、析构部分
		list()
		{
			empty_init();
		}

		list(size_t n, const T& value = T())
		{
			empty_init();
			while (n--)
			{
				push_back(value);
			}
		}

		//重载给内置类型使用,整形默认是int，不写这个会优先匹配list(Iterator first, Iterator last)
		list(int n, const T& value = T())
		{
			empty_init();
			while (n--)
			{
				push_back(value);
			}
		}

		//迭代器区间初始化
		template <class Iterator>
		list(Iterator first, Iterator last)
		{
			empty_init();
			while(first != last)
			{
				push_back(*first);
				first++;
			}
		}

		list(const list<T>& lt)
		{
			empty_init();
			for (auto e : lt)
			{
				push_back(e);
			}
		}

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


		//其它
		void swap(list<T> lt)
		{
			std::swap(_size, lt._size);
			std::swap(_head, lt._head);
		}

		//使用传之传参，直接拷贝一份交换操作的底层空间就好
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

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

	
		/// /
		/

		//访问头，尾数据
		T& front()
		{
			return _head->_next->_data;
		}

		const T& front()const
		{
			return _head->_next->_data;
		}

		T& back()
		{
			return _head->_prev->_data;
		}

		const T& back()const
		{
			return _head->_prev->_data;
		}



		/// //
		/// 

		//增加删除部分
		void push_back(const T& val)
		{
			insert(end(), val);
		}

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

		iterator insert(iterator pos, const T& val)
		{
			Node* newnode = new Node(val);
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			cur->_prev = newnode;
			newnode->_next = cur;
			newnode->_prev = prev;
			prev->_next = newnode;

			++_size;
			return newnode;
		}

		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->_next;

			prev->_next = next;
			next->_prev = prev;
			delete cur;

			--_size;
			return next;
		}

		//获取有效数据量
		size_t size()
		{
			return _size;
		}

	private:
		Node* _head;  //这里存储卫兵节点，因为底层是双向循环链表，可以找到头和尾
		size_t _size; //只需要在insert和erase里面加减就可以
	};

}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MySQL不停重启问题

MySQL不停重启问题

MySQL不停的自动杀掉自动重启 看一下log日志 my.cnf 里配置的 log_error /var/log/mysqld.log vim /var/log/mysqld.log 报的错误只是 [ERROR] Cant start server: Bind on TCP/IP port: Address already in use [ERROR] Do you already have another mysqld server …
阅读更多...
LLMs高效的多 GPU 计算策略Efficient multi-GPU compute strategies

LLMs高效的多 GPU 计算策略Efficient multi-GPU compute strategies

很有可能在某个时候&#xff0c;您需要将模型训练工作扩展到超过一个GPU。在上一个视频中&#xff0c;我强调了当您的模型变得太大而无法适应单个GPU时&#xff0c;您需要使用多GPU计算策略。但即使您的模型确实适合单个GPU&#xff0c;使用多个GPU加速训练也有好处。即使您正在…
阅读更多...
Java 项目日志实例：综合应用

Java 项目日志实例：综合应用

点击下方关注我&#xff0c;然后右上角点击...“设为星标”&#xff0c;就能第一时间收到更新推送啦~~~ 本文介绍 JCL(java common logging) 和 SLF4J 分别与 Log4j 结合使用的示例。 1 JCL Log4j 使用示例 1、JCL(java common logging) Log4j 介绍 使用 commons-logging 的 …
阅读更多...
Java 实战项目-SpringBoot+Vue 的智慧养老平台，附源码、教程

Java 实战项目-SpringBoot+Vue 的智慧养老平台，附源码、教程

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝30W,Csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ 文章目录 1.研究背景2. 技术栈3.系统分析4系统设计4.1 软件功能模块设计4.2数据库设计与实现 5系统详细设计…
阅读更多...
bode100测量频率响应的基本原理

bode100测量频率响应的基本原理

当使用Bode 100进行频率响应测量时&#xff0c;它会同时测量幅频响应曲线和相频响应曲线。下面是对这两个曲线测量方法的进一步解释&#xff1a; 幅频响应曲线测量&#xff1a; 幅频响应曲线描述了系统在不同频率下输入信号的幅度变化。Bode 100通过以下步骤测量并绘制幅频响应…
阅读更多...
基于Jenkins自动打包并部署Tomcat环境

基于Jenkins自动打包并部署Tomcat环境

目录 1、配置git主机 2、配置jenkins主机 3、配置web主机 4、新建Maven项目 5、验证 Jenkins 自动打包部署结果 Jenkins 的工作原理是先将源代码从 SVN/Git 版本控制系统中拷贝一份到本地&#xff0c;然后根据设置的脚本调用Maven进行 build&#xff08;构建&#xff09;。…
阅读更多...
框架分析（2）-React

框架分析（2）-React

框架分析&#xff08;2&#xff09;-React 专栏介绍React核心思想关键特性和功能组件化开发单向数据流JSX语法强大的生态系统 优缺点分析优点缺点 专栏介绍 link 主要对目前市面上常见的框架进行分析和总结&#xff0c;希望有兴趣的小伙伴们可以看一下&#xff0c;会持续更新的…
阅读更多...
网络：RIP协议

网络：RIP协议

1. RIP协议原理介绍 RIP是一种比较简单的内部网关协议&#xff08;IGP协议&#xff09;&#xff0c;RIP基于距离矢量的贝尔曼-福特算法(Bellman - Ford)来计算到达目的网络的最佳路径。最初的RIP协议开发时间较早&#xff0c;所以在带宽、配置和管理方面的要求也较低。 路由器运…
阅读更多...
Linux下的Shell编程——正则表达式入门（四）

Linux下的Shell编程——正则表达式入门（四）

前言&#xff1a; 正则表达式使用单个字符串来描述、匹配一系列符合某个语法规则的字符串。在很多文本编辑器里&#xff0c;正则表达式通常被用来检索、替换那些符合某个模式的文本。 在Linux 中&#xff0c;grep&#xff0c;sed&#xff0c;awk 等文本处理工具都支持…
阅读更多...
一句话木马攻击复现：揭示黑客入侵的实战过程

一句话木马攻击复现：揭示黑客入侵的实战过程

准备环境 OWASP虚拟机xfp 7与xshell 7 ​ DVWA系统默认的账号密码均为&#xff1a;admin/admin 1、命令注入中复现 ​ 攻击payload 127.0.0.1 | echo "<?php eval(\$_POST[\"cmd\"])?>" > /var/www/shell.php 这个命令的目的是在服务器…
阅读更多...
从一些常见的错误聊聊mysql服务端的关键配置 | 京东云技术团队

从一些常见的错误聊聊mysql服务端的关键配置 | 京东云技术团队

背景 每一年都进行大促前压测&#xff0c;每一次都需要再次关注到一些基础资源的使用问题&#xff0c;订单中心这边数据库比较多&#xff0c;最近频繁报数据库异常&#xff0c;所以对数据库一些配置问题也进行了研究&#xff0c;本文给出一些常见的数据库配置&#xff0c;说明…
阅读更多...
聚类分析 | MATLAB实现GMM高斯分布混合模型的聚类结果可视化

聚类分析 | MATLAB实现GMM高斯分布混合模型的聚类结果可视化

聚类分析 | MATLAB实现GMM高斯分布混合模型的聚类结果可视化 目录 聚类分析 | MATLAB实现GMM高斯分布混合模型的聚类结果可视化效果一览基本介绍程序设计参考资料 效果一览 基本介绍 聚类分析 | MATLAB实现GMM高斯分布混合模型的聚类结果可视化&#xff0c;GMM聚类&#xff0c;…
阅读更多...
抖音短视频矩阵系统源码开发搭建技术开源分享

抖音短视频矩阵系统源码开发搭建技术开源分享

前言&#xff1a;抖音矩阵号/抖音短视频SEO矩阵系统源码开发&#xff0c;优化排名。 短视频获客系统支持短视频智能剪辑、短视频定时发布&#xff0c;短视频排名查询及优化&#xff0c;智能客服等&#xff0c;那么短视频seo系统开发时需要开发哪些功能呢&#xff1f;今天我就跟…
阅读更多...
会计资料（借贷记账法、试算平衡）

会计资料（借贷记账法、试算平衡）

6.借贷记账法 这样的格式是会计学家提出的。 6.1 借贷记账法的详细使用 这里要把会计的六大分类搞明白&#xff0c;才能够使用借贷记账法 6.2 借贷记账法的记账规则 6.3 借贷记账法下的账户与会计分录 6.4 会计分录的介绍 这里一笔会计分录只能写一笔经济业务&#xff0c;或者…
阅读更多...
Android 面试之Glide做了哪些优化?

Android 面试之Glide做了哪些优化?

前言 Glide可以说是最常用的图片加载框架了&#xff0c;Glide链式调用使用方便&#xff0c;性能上也可以满足大多数场景的使用&#xff0c;Glide源码与原理也是面试中的常客。 但是Glide的源码内容比较多&#xff0c;想要学习它的源码往往千头万绪&#xff0c;一时抓不住重点.…
阅读更多...
1079. 活字印刷；1593. 拆分字符串使唯一子字符串的数目最大；1814. 统计一个数组中好对子的数目

1079. 活字印刷；1593. 拆分字符串使唯一子字符串的数目最大；1814. 统计一个数组中好对子的数目

1079. 活字印刷 核心思想&#xff1a;回溯法&#xff0c;其实这题就是排列组合&#xff0c;只不过这题是每一个分支都要收集一次结果&#xff0c;然后去重。这里的代码用的是标准的used标记的方法。 1593. 拆分字符串使唯一子字符串的数目最大 核心思想&#xff1a;回溯。拆分…
阅读更多...
ensp单臂路由

ensp单臂路由

文章目录 单臂路由速览版本 单臂路由DHCP速览版本 单臂路由 速览版本 R1 # interface Ethernet0/0/0.10dot1q termination vid 10ip address 192.168.1.254 255.255.255.0arp broadcast enable # interface Ethernet0/0/0.20dot1q termination vid 20ip address 192.168.2.2…
阅读更多...
你不能不知道的Mydatis扩展：动态sql以及模糊查询，结果映射！

你不能不知道的Mydatis扩展：动态sql以及模糊查询，结果映射！

一.Mydatis中的动态sql 1.Mydatis中的动态sql出现背景&#xff1f; 任何技术的出现都不是空穴来风&#xff0c;一切都是有迹可循的&#xff01;而动态sql同样如此&#xff01; 1.1传统sql语句 MyBatis 中出现动态 SQL 的背景是&#xff1a;为了解决传统 SQL 查询的静态性和硬…
阅读更多...
vim 常见操作

vim 常见操作

Vim 工作模式 1、vim 三种基本的工作模式 vim有三种基本的工作模式&#xff0c;分别为&#xff1a;命令模式、末行模式、编辑模式。关于这三种工作模式的介绍&#xff0c;请见下文。 1.1、命令模式 使用vim打开文件之后&#xff0c;首先进入命令模式&#xff0c;它是vim编辑…
阅读更多...
面试之快速学习STL-常用算法

面试之快速学习STL-常用算法

1. 排序算法 sort() 函数是基于快速排序实现的&#xff0c;故不保证相对位置&#xff0c;但是stable_sort (first, last)保证&#xff0c;它基于归并排序。sort()只适用于支持随机迭代器的容器&#xff08;array, vector, deque&#xff09;&#xff0c;好理解&#xff0c;毕竟…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023