List ---- 模拟实现LIST功能的发现

news2025/1/8 13:08:26

目录

  • list
    • list概念
  • list 中的迭代器
    • list迭代器知识
    • const迭代器写法
    • list访问自定义类型
  • 附录代码

list

list概念

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

在这里插入图片描述

list 中的迭代器

有兴趣的可以直接跳转附录代码中，里面几乎涵盖了所有的问题答案

list迭代器知识

迭代器原理就是对原生指针的封装，帮助我们更好的使用指针来对节点的内容进行访问。

迭代器目前学习的进度来看是分成普通迭代器和const迭代器。在对list的模拟实现过程中发现了许多新的迭代器知识点。

const迭代器写法

由于对迭代器封装后的代码重命名为：typedef __list_iterator<T > iterator;
所以下意识会认为const迭代器应该是这个样子的：//typedef __list_const_iterator<T> const_iterator;
实际上这是有问题的！

因为const迭代器修饰的应该节点内部的数据不可以被修改，而迭代器本身是可以前后移动来遍历链表。 而 const_iterator所表达的意思是T* const，但是我们想要的是const T*。 这两者的区别便是前一个T* const可以修改节点内部数据信息，但因为不可以修改地址所以不能遍历链表，，而后一个const T*不可以修改数据信息，但是可以遍历链表。
要想办法实现const T*！！！！

list中的const迭代器实际上是保证对信息不可修改，所以只需要对读取信息的操作赋予控制是否为const属性的操作，即为T* operator*()确保在某些时刻是const属性。所以可以在模板上对其进行特殊化操作： template<class T, class Ref>

	template<class T, class Ref>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref> self;
		node* _node;
		__list_iterator(node* n)
			:_node(n)
		{}

		Ref operator*()//T* operator()
		{
			return _node->_data;
		}
	};
	template<class T>
	class list
	{
		typedef list_node<T> node;
	public:
		typedef __list_iterator<T, T&> iterator;//使用普通迭代器就更改Ref就好了
		typedef __list_iterator<T, const T&> const_iterator;

在需要const迭代器时候，传递const T&，而需要普通迭代器就直接传递T&,这样不仅解决的繁琐的复用问题，还能够满足使用。

list访问自定义类型

迭代器要么是原生指针，要么是自定义类型对原生指针的封装，在模拟指针的行为。

而访问自定义类型不能使用解引用操作，而是使用访问操作符->,所以list库对访问自定义类型也做了对应的设置，即重载operator->

但是因为要访问自定义类型就一棒子大打死，就只能使用operator->来进行访问，内部的函数大可以直接访问，而复用又太过于繁琐了，所以又新增了特殊的模板类，控制是访问自定义类型还是访问内部函数！

	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref, Ptr> self;
		node* _node;
		__list_iterator(node* n)
			:_node(n)
		{}
		Ptr operator->()
		{
			return &_node->_data;
		}
		template<class 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;
	}

	struct AA
	{
		int _a1;
		int _a2;

		AA(int a1 = 0, int a2 = 0)//全缺省的默认构造
			:_a1(a1)
			, _a2(a2)
		{}
	};

	void test_list2()
	{
		list<AA> lt;
		lt.push_back(AA(1, 1));
		lt.push_back(AA(2, 2));
		lt.push_back(AA(3, 3));
		list<AA>::iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << it->_a1 << "," << it->_a2 << " ";
			++it;
		}
		cout << endl;
	}

因此不仅仅可以访问是否为const属性的信息，还可以控制访问是否为自定义类型的参数

附录代码

#pragma once

#include<iostream>
#include<assert.h>
using namespace std;
namespace lby
{
	template<class T>
	struct list_node //节点的类//struct默认为公有，不打算对内容进行限制就用struct
	{
		list_node<T>* _next;
		list_node<T>* _prev;
		T _data;

		list_node(const T& x = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{}
	};


	//迭代器要么是原生指针，要么是自定义类型对原生指针的封装，在模拟指针的行为

	template<class T, class Ref, class Ptr>//使用普通迭代器就更改Ref就好了
	struct __list_iterator//封装的是迭代器，而迭代器的本质是用一个类去封装这个 node*,即指针指向这个链表的头节点
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref, Ptr> self;
		node* _node;//注意节点的指针不属于迭代器，只是让迭代器封装之后的一系列操作，不支持释放，释放是链表的事情，迭代器只能使用节点，不能释放节点

		__list_iterator(node* n)
			:_node(n)
		{}

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

		Ptr operator->()
		{
			return &_node->_data;
		}
		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;
		}

		bool operator!=(const self& x)//传递的是迭代器中的x
		{
			return _node != x._node;
		}
		bool operator==(const self& x)
		{
			return _node == x._node;
		}
	};

	/*template<class T>
	struct __list_const_iterator//封装的是迭代器，而迭代器的本质是用一个类去封装这个 node*,即指针指向这个链表的头节点
	{
		typedef list_node<T> node;
		typedef __list_const_iterator<T> self;
		node* _node;//注意节点的指针不属于迭代器，只是让迭代器封装之后的一系列操作，不支持释放，释放是链表的事情，迭代器只能使用节点，不能释放节点

		__list_const_iterator(node* n)
			:_node(n)
		{}

		const T& operator*()//控制整个返回值不可修改
		{
			return _node->_data;
		}

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

		bool operator!=(const self& x)//传递的是迭代器中的x
		{
			return _node != x._node;
		}
		bool operator==(const self& x)
		{
			return _node == x._node;
		}
	};*/


	template<class 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 __list_const_iterator<T>  const_iterator;

		//typedef const iterator const_itrator;//绝对不可以，这种方式const修饰的是地址 --> T* const，而不是const T*；


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

		//iterator begin() const//这里有个问题，既然是const指针，那就应该是常量，但是为什么你还能改变指向的位置？
		//{
		//	return iterator(_head->_next);//因为const指针修饰的是*this，即this指针指向的内容，它指向的内容是_head这个的指针，
		//								  //即为修饰的是_head这个指针本身！也就是说_head本身不能被改变，它指向的内容是可以改变的
		//								  //但是与我们的预期不符，因为const迭代器他是只读操作，不允许改变内容，如果他内容是可以改变的，我为什么要使用const迭代器呢
		const迭代器与普通迭代器区别是：const迭代器本身是可以修改的(可以前后移动去访问)，但是const迭代器指向的内容是不可以修改的--> 要const T*，不要T* const ！
		//}
		//iterator end() const
		//{
		//	return iterator(_head); 
		//}

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

		void empty_init()
		{
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;
		}

		list()
		{
			empty_init();
		}

		template<class Iterator>
		list(Iterator first, Iterator last)
		{
			empty_init();//先构造头节点

			while (first != last)
			{
				push_back(*first);//push_back 的前提是有哨兵位的头节点，所以需要先构造头节点
				++first;
			}
		}

		void swap(list<T>& t)
		{
			std::swap(_head, t._head);
		}

		list(const list<T>& lt)//lt2(lt1)
		{
			/*empty_init();//正常写法
			for (auto e : lt)
			{
				push_back(e);
			}*/
			empty_init();
			list<T> tmp(lt.begin(), lt.end());//借助模板类进行复制后交换
			swap(tmp);
		}

		//lt1 = lt3	
		list<T>& operator=(list<T> lt)//(list<T>& lt)不能引用传引用，因为会将原来的lt进行修改
		{
			swap(lt);
			return *this;
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
				//erase(it++);//这个地方析构的值是返回的迭代器对象，是it的拷贝，不是it
			}
		}

		void push_back(const T& x)
		{
			//node* tail = _head->_prev;
			//node* new_node = new node(x);//需要node(list_node<T>)的构造函数

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

			insert(end(), x);
		}

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

		void insert(iterator pos, const T& x)//链表的迭代器插入数据不会失效，因为pos指针指向的位置是不变的
		{
			node* cur = pos._node;
			node* prev = cur->_prev;

			node* new_node = new node(x);

			prev->_next = new_node;
			new_node->_prev = prev;
			new_node->_next = cur;
			cur->_prev = new_node;
		}

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

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

		iterator erase(iterator pos)//由于pos指针位置被析构了，所以迭代器失效了
		{
			assert(pos != end());

			node* prev = pos._node->_prev;
			node* next = pos._node->_next;

			prev->_next = next;
			next->_prev = prev;
			delete pos._node;

			return iterator(next);
		}

	private:
		node* _head;
	};

	void print_list(const list<int>& lt)
	{
		list<int>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			//(*it) *= 2;//const不可修改
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}


	void test_list1()
	{
		const list<int> l;//const对象在定义时，最开始不会赋给常值，因为要初始化，否则没办法进行初始化，之后才会赋给const属性
						 //const对象在定义的一瞬间不会给const属性

		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);

		list<int>::iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		print_list(lt);
	}

	struct AA
	{
		int _a1;
		int _a2;

		AA(int a1 = 0, int a2 = 0)//全缺省的默认构造
			:_a1(a1)
			, _a2(a2)
		{}
	};

	void test_list2()
	{
		list<AA> lt;
		lt.push_back(AA(1, 1));
		lt.push_back(AA(2, 2));
		lt.push_back(AA(3, 3));

		list<AA>::iterator it = lt.begin();
		while (it != lt.end())
		{
			//cout << (*it)._a1 << " " << (*it)._a2 << " ";
			cout << it->_a1 << "," << it->_a2 << " ";//由于函数重载了 -> ，所以本来应该是it->->_a1,编译器优化了设置，变成了it->_a1;
													 //it.operator->()->_a1,it.operator->()返回的是T*，T*->_a1就可以访问
			++it;
		}
		cout << endl;
	}


	void test_list3()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);

		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		auto pos = lt.begin();
		++pos;
		lt.insert(pos, 100);

		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.push_front(200);
		lt.push_front(300);
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.push_back(400);
		lt.push_back(500);
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.pop_back();
		lt.pop_front();
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;
	}


	void test_list4()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.clear();
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;
		lt.push_back(10);
		lt.push_back(2);
		lt.push_back(30);
		lt.push_back(1);
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;
	}

	void test_list5()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);

		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		list<int> lt2(lt);
		for (auto e : lt2)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

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

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

相关文章

STM32-笔记37-吸烟室管控系统项目

STM32-笔记37-吸烟室管控系统项目

一、项目需求 1. 使用 mq-2 获取环境烟雾值&#xff0c;并显示在 LCD1602 上&#xff1b; 2. 按键修改阈值&#xff0c;并显示在 LCD1602 上&#xff1b; 3. 烟雾值超过阈值时&#xff0c;蜂鸣器长响&#xff0c;风扇打开&#xff1b;烟雾值小于阈值时&#xff0c;蜂鸣器不响…
阅读更多...
VUE3配置后端地址,实现前后端分离及开发、正式环境分离

VUE3配置后端地址,实现前后端分离及开发、正式环境分离

新建.env.development及.env.production .env.development 指定开发环境地址.env.production 指定生产环境地址 格式如下 VITE_APP_BASE_APIhttp://localhost:8070只需要在对应文件写入对应的后端地址即可 修改env.d.ts /// <reference types"vite/client" /…
阅读更多...
win32汇编环境，在窗口程序中画五边形与六边形

win32汇编环境，在窗口程序中画五边形与六边形

;运行效果 ;win32汇编环境，在窗口程序中画五边形与六边形 ;展示五边形与六边形的画法 ;将代码复制进radasm软件里，直接编译可运行.重要部分加备注。 ;下面为asm文件 ;>>>>>>>>>>>>>>>>>>>>>>>>>…
阅读更多...
Java Web开发进阶——Spring Boot基础

Java Web开发进阶——Spring Boot基础

Spring Boot是基于Spring框架的新一代开发框架&#xff0c;旨在通过自动化配置和简化的开发方式提升生产效率。它将复杂的配置抽象化&#xff0c;让开发者专注于业务逻辑实现&#xff0c;而无需关注繁琐的基础配置。 1. Spring Boot简介与优势 Spring Boot 是 Spring 家族中的…
阅读更多...
【Linux】文件系统命令

【Linux】文件系统命令

目录 文件系统命令 Linux文件系统 文件操作相关命令 文件系统命令 磁盘文件系统&#xff1a;指本地主机中实际可以访问到的文件系统&#xff0c;包括硬盘、CD-ROM、DVD、USB存储器、磁盘阵列等。常见文件系统格式有&#xff1a;autofs、coda、Ext&#xff08;Extended File…
阅读更多...
关于变电站及线路接线情况展示的一些想法

关于变电站及线路接线情况展示的一些想法

以前总项目的时候总习惯于给变电站画个轮廓和接线点&#xff0c;要不就是给变电站3D建模。费时、费力效果还不一定好!其实&#xff0c;像上图一样线路搭配高清影像效果是不是会更好&#xff1f;尤其变电站区域可以使用航飞0.2米左右的数据&#xff0c;基本上站内设备都能看清了…
阅读更多...
【OceanBase】使用 Superset 连接 OceanBase 数据库并进行数据可视化分析

【OceanBase】使用 Superset 连接 OceanBase 数据库并进行数据可视化分析

文章目录 前言一、前提条件二、操作步骤2.1 准备云主机实例2.2 安装docker-compose2.3 使用docker-compose安装Superset2.3.1 克隆 Superset 的 GitHub 存储库2.3.2 通过 Docker Compose 启动 Superset 2.4 开通 OB Cloud 云数据库2.5 获取连接串2.6 使用 Superset 连接 OceanB…
阅读更多...
开源平台Kubernetes的优势是什么？

开源平台Kubernetes的优势是什么？

Kubernetes 是一个可移植、可扩展的开源平台&#xff0c;用于管理容器化的工作负载和服务&#xff0c;方便进行声明式配置和自动化。Kubernetes 拥有一个庞大且快速增长的生态系统&#xff0c;其服务、支持和工具的使用范围广泛。 Kubernetes 这个名字源于希腊语&#xff0c;意…
阅读更多...
“大数据+职业本科”：VR虚拟仿真实训室的发展前景

“大数据+职业本科”：VR虚拟仿真实训室的发展前景

在新时代背景下&#xff0c;随着科技的飞速进步和产业结构的不断升级&#xff0c;职业教育正迎来前所未有的变革。“大数据职业本科”的新型教育模式&#xff0c;结合VR&#xff08;虚拟现实&#xff09;技术的广泛应用&#xff0c;为实训教学开辟了崭新的道路&#xff0c;尤其…
阅读更多...
flask实现国外大学生志愿者管理服务系统【英文】

flask实现国外大学生志愿者管理服务系统【英文】

完整源码项目包获取→点击文章末尾名片&#xff01;
阅读更多...
lambda用法及其原理

lambda用法及其原理

目录 lambda形式lambda用法1.sort降序2.swap3.捕捉列表 习题解题 lambda形式 [capture-list](parameters)->return type{function boby}[capture-list]&#xff1a;[捕捉列表]用于捕捉函数外的参数&#xff0c;可以为空&#xff0c;但不能省略&#xff1b;(parameters) &am…
阅读更多...
Street Surf 的学习

Street Surf 的学习

数据结构和组织 定义了一个 scenebank 的 数据结构。 这篇文章定义了两种 采样 方式&#xff1a; JointFramePixelDataset 【任意帧中选择任意的 Pixel】PixelDataset [从固定的帧中选择任意的Pixel]ImagePatchDataset [基于image patch 的采样方式&#xff0c;可以用于 mono…
阅读更多...
IP查询于访问控制保护你我安全

IP查询于访问控制保护你我安全

IP地址查询 查询方法&#xff1a; 命令行工具&#xff1a; ①在Windows系统中&#xff0c;我们可以使用命令提示符&#xff08;WINR&#xff09;查询IP地址&#xff0c;在弹窗中输入“ipconfig”命令查看本地网络适配器的IP地址等配置信息&#xff1b; ②在Linux系统中&…
阅读更多...
大模型 LangChain-LangGraph 初探

大模型 LangChain-LangGraph 初探

大模型 LangChain-LangGraph 初探 一、LangGraph 简介 LangGraph&#xff08;https://langchain-ai.github.io/langgraph/&#xff09;是一个用于构建有状态、多参与者应用程序的库&#xff0c;在创建代理和多代理工作流方面发挥着重要作用。与其他大语言模型&#xff08;LLM…
阅读更多...
yolov5核查数据标注漏报和误报

yolov5核查数据标注漏报和误报

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、误报二、漏报三、源码总结 前言 本文主要用于记录数据标注和模型预测之间的漏报和误报思想及其源码 提示&#xff1a;以下是本篇文章正文内容&#xff0c;…
阅读更多...
【Linux】进程间通信（一）

【Linux】进程间通信（一）

目录 一、进程间通信1.1 进程间通信目的1.2 理解进程间通信1.3 进程间通信发展1.4 进程间通信分类 二、管道2.1 什么是管道2.2 管道的原理2.3 匿名管道2.3.1 pipe函数2.3.2 匿名管道的实现2.3.3 匿名管道小结2.3.3.1 匿名管道的四种情况2.3.3.2 匿名管道的五种特性 2.3.4 匿名管…
阅读更多...
【QT-QTableView实现鼠标悬浮（hover）行高亮显示+并设置表格样式】

【QT-QTableView实现鼠标悬浮（hover）行高亮显示+并设置表格样式】

1、自定义委托类 HoverDelegate hoverdelegate.h #ifndef HOVERDELEGATE_H #define HOVERDELEGATE_H#include <QObject> #include <QStyledItemDelegate>class hoverdelegate : public QStyledItemDelegate {Q_OBJECT // 添加 Q_OBJECT 宏public:explicit hoverde…
阅读更多...
Elasticsearch：基础概念

Elasticsearch：基础概念

这里写目录标题 一、什么是Elasticsearch1、基础介绍2、什么是全文检索3、倒排索引4、索引&#xff08;1&#xff09;创建索引a 创建索引基本语法b 只定义索引名&#xff0c;setting、mapping取默认值c 创建一个名为student_index的索引&#xff0c;并设置一些自定义字段 &…
阅读更多...
RAG Logger：RAG日志记录工具

RAG Logger：RAG日志记录工具

您听说过 RAG Logger 吗&#xff1f; 它是一款专为检索增强生成 (RAG) 应用程序设计的开源日志记录工具&#xff01; 据说它可以作为 LangSmith 的轻量级替代方案&#xff0c;满足 RAG 特定的日志记录需求。 查询、搜索结果、LLM 交互和性能指标可以以 JSON 格式记录。 特点 …
阅读更多...
Spark-Streaming有状态计算

Spark-Streaming有状态计算

一、上下文 《Spark-Streaming初识》中的NetworkWordCount示例只能统计每个微批下的单词的数量&#xff0c;那么如何才能统计从开始加载数据到当下的所有数量呢&#xff1f;下面我们就来通过官方例子学习下Spark-Streaming有状态计算。 二、官方例子 所属包&#xff1a;org.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023