【C++笔记】list使用详解及模拟实现

news2024/11/25 23:03:12

前言

各位读者朋友们大家好！上期我们讲了vector的使用以及底层的模拟实现，这期我们来讲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
  • 二. list的模拟实现
    • 2.1 list的底层结构
    • 2.2 普通迭代器
    • 2.3 const迭代器
    • 2.4 insert
    • 2.5 erase
    • 2.6 迭代器失效
    • 2.7 list的析构函数
    • 2.9 list的构造函数
    • 2.8 operator=
  • 三. 按需实例化
  • 四. initializer_list
  • 五. list.h
  • 结语

一. list的介绍及使用

1.1 list的介绍

list的文档
在这里插入图片描述
这里的list就是双向带头循环链表

在这里插入图片描述

1.2 list的使用

list的接口较多，我们要先掌握如何正确的使用，然后再去深入研究底层的原理，以达到可扩展的能力。以下是list的一些常见的重要接口。

1.2.1 list的构造

构造函数(Constructor)接口说明
list (size_type n, const value_type& val = value_type())构造的list中包含n个值为val的元素
list()构造空的list
list(const list& x)拷贝构造
list(InputItetator first,InputIterator last)用一段迭代器区间构造list
  • list (size_type n, const value_type& val = value_type())
    在这里插入图片描述
  • list()
    在这里插入图片描述
  • list(const list& x)
    在这里插入图片描述
  • list(InputItetator first,InputIterator last)
    在这里插入图片描述

1.2.2 list iterator的使用

这里我们暂时将list的迭代器理解为指针，该指针指向list中的某一节点

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

可以看到这里的list的迭代器是双向的迭代器
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
如果想在某个位置插入元素就不能对迭代器进行+运算了
这里我们在第三个位置之前插入1314，要对begin进行三次自加，而不能使用begin+3

list<int> l(5, 520);
int k = 3;
list<int>::iterator it = l.begin();
while (k--)
{
	++it;
}
l.insert(it, 1314);
for (auto a : l)
{
	cout << a << " ";
}
cout << endl;

在这里插入图片描述

1.2.3 list capacity

函数声明接口说明
empty检测list是否为空，是返回true，否则返回false
size返回list的有效节点个数
void test_list2()
{
	list<int> l1,l2;
	if (l1.empty())
	{
		cout << "true" << endl;
		cout << l1.size() << endl;
	}
	else
	{
		cout << "false" << endl;
		cout << l1.size() << endl;
	}
	l2.push_back(1314);
	cout << l2.size() << endl;
}

在这里插入图片描述

1.2.4 list element access

函数声明接口说明
front返回list的第一个节点中的值的引用
back返回list的最后一个节点中的值的引用
void test_list3()
{
	list<int> l;
	l.push_back(520);
	l.push_back(520);
	l.push_back(520);
	l.push_back(520);
	for (auto a : l)
	{
		cout << a << " ";
	}
	cout << endl;
	l.front() = 1314;
	l.back() = 1314;
	for (auto a : l)
	{
		cout << a << " ";
	}
}

在这里插入图片描述
将第一个和最后一个位置的值改为了1314

1.2.5 list modifiers

函数声明接口说明
push_front在list首元素之前插入值为val的元素
pop_front删除list的第一个元素
push_back尾插值为val的元素
emplace_back尾插一个元素
pop_back将list的最后一个元素删除
insert在pos位置插入值为val的元素
erase删除pos位置的元素

  • push_front
    在这里插入图片描述

  • pop_front
    在这里插入图片描述

  • push_back 和 pop_back
    在这里插入图片描述

  • emplace_back
    在这里插入图片描述
    emplace_back在功能上跟push_back类似。但是emplace_back支持直接构造，不用再拷贝构造了，在最后一种情况下emplace_back比push_back高效。

  • insert 和 erase
    在这里插入图片描述

  • splice
    在这里插入图片描述
    将一个链表插到另一个链表的指定位置

void test_list4()
{
	list<int> lt1,lt2;
	lt1.push_back(520);
	lt1.push_back(520);
	lt2.push_back(1314);
	lt2.push_back(1314);
	lt1.splice(lt1.begin(), lt2);
	for (auto a : lt1)
	{
		cout << a << " ";
	}
	cout << endl;
	for (auto a : lt2)
	{
		cout << a << " ";
	}
}

在这里插入图片描述
插入后lt2就被置空了。
这一接口也可以用来调整结点的顺序
在这里插入图片描述

  • merge
    在这里插入图片描述
    这一功能的实现的是有序链表的合并
    在这里插入图片描述
    将大的尾插到一个头节点后最后将头节点接到lt1上

上面就讲完了list常用接口的使用，下面我们开始模拟实现list

二. list的模拟实现

2.1 list的底层结构

template <class T>// 链表的节点
struct list_node
{
	T _data;
	list_node<T>* _next;
	list_node<T>* _prev;
	list_node(const T& x = T())
		:_data(x)
		, _next(nullptr)
		, _prev(nullptr)
	{}
};

template <class T>
class list
{
	typedef list_node<T> Node;
public:
list()
{
	_head = new Node;
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}
private:
	Node* _head;
	size_t _size;
};

2.2 普通迭代器

因为list的节点在内存中不是连续存储的，因此不能使用原生指针作为迭代器，我们可以封装一个类来作为迭代器，通过运算符重载来实现迭代器的功能。

template <class T>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T> Self;
	Node* _node;
	list_iterator(Node* node)
		:_node(node)
	{}

	T& operator*()
	{
		return _node->_data;
	}
	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 *this;
	}
	bool operator==(const Self& s) const
	{
		return _node == s._node;
	}
	bool operator!=(const Self& s) const
	{
		return _node != s._node;
	}
};

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3 const迭代器

在这里插入图片描述
但是这样要写成两个类，而且两个类的方法只有两个不同，很是冗余，有没有方法能实现成一个类呢？
我们看一下库里是如何实现的：
在这里插入图片描述

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* node)
		:_node(node)
	{}
	Ptr operator -> ()
	{
		return &_node->_data;
	}
	Ref 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 *this;
	}
	bool operator==(const Self& s) const
	{
		return _node == s._node;
	}
	bool operator!=(const Self& s) const
	{
		return _node != s._node;
	}
};

写一段程序来体现一下实例化的过程
在这里插入图片描述

2.4 insert

在这里插入图片描述

iterator insert(iterator pos, const T& x)
{
	Node* newnode = new Node(x);
	Node* cur = pos._node;
	Node* prev = cur->_prev;
	// prev newnode cur
	newnode->_prev = prev;
	newnode->_next = cur;
	cur->_prev = newnode;
	prev->_next = newnode;
	++_size;
	return newnode;
}

有了insert我们可以服复用hinsert来实现push_back和push_front

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

2.5 erase

将pos节点的前节点和后节点相连然后将pos节点释放即可
在这里插入图片描述

iterator erase(iterator pos)
{
	assert(pos != end());
	Node* next = pos._node->_next;
	Node* prev = pos._node->_prev;
	next->_prev = prev;
	prev->_next = next;
	delete pos._node;
	--_size;
	
	return next;
}

有了erase就可以复用erase来实现pop_back和pop_front了

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

2.6 迭代器失效

在这里插入图片描述

2.7 list的析构函数

~list()
{
	clear();
	delete _head;
	_head = nullptr;
}
void clear()
{
	auto it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}

将所有节点删除之后再将头结点释放

2.9 list的构造函数

void empty_init()
{
	_head = new Node;
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}
list()
{
	empty_init();
}
list(const list<T>& tmp)
{
	empty_init();
	for (auto& a : tmp)
	{
		push_back(a);
	}
}

构造一个头节点，将tmp的节点尾插到头节点后

2.8 operator=

	list<T>& operator=(list<T> tmp)
	{
		swap(tmp);
		return *this;
	}

依旧是现代写法
在这里插入图片描述

三. 按需实例化

编译器在对模板进行实例化的时候，使用哪些成员函数就实例化哪些成员函数，不会全部实例化。
在这里插入图片描述

四. initializer_list

C++11中支持下面的写法：
在这里插入图片描述
不需要一直push_back数据，这里是因为支持了initializer_list
在这里插入图片描述
initializer_list底层是两个指针，第一个指针指向第一个数据，第二个指针指向最后一个数据的下一位置
在这里插入图片描述
我们写的list如果要支持这种写法需要写一个新的构造函数
在这里插入图片描述

list(initializer_list<T> il)
{
	empty_init();
	for (auto& a : il)
	{
		push_back(a);
	}
}

跟普通的构造函数一样，只是参数变了而已，最正确的写法应该如下，因为我们是构造函数
在这里插入图片描述
在这里插入图片描述
这样就是隐式类型转换了
在这里插入图片描述
所以就有了下面的玩法：
在这里插入图片描述

五. list.h

namespace Yuey
{
	template <class T>// 链表的节点
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;
		list_node(const T& x = T())
			:_data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};
	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* node)
			:_node(node)
		{}
		Ptr operator -> ()
		{
			return &_node->_data;
		}
		Ref 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 *this;
		}
		bool operator==(const Self& s) const
		{
			return _node == s._node;
		}
		bool operator!=(const Self& s) const
		{
			return _node != s._node;
		}
	};

	struct AA
	{
		int _a1 = 520;
		int _a2 = 1314;
	};

	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;
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
		list()
		{
			empty_init();
		}
		list(initializer_list<T> il)
		{
			empty_init();
			for (auto& a : il)
			{
				push_back(a);
			}
		}
		list(const list<T>& tmp)
		{
			empty_init();
			for (auto& a : tmp)
			{
				push_back(a);
			}
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		void swap(list<T>& tmp)
		{
			std::swap(_head, tmp._head);
			std::swap(_size, tmp._size);
		}
		list<T>& operator=(list<T> tmp)
		{
			swap(tmp);
			return *this;
		}
		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}
		const_iterator end() const
		{
			return _head;
		}
		iterator insert(iterator pos, const T& x)
		{
			Node* newnode = new Node(x);
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			// prev newnode cur
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			prev->_next = newnode;
			++_size;

			return newnode;
		}
		void push_back(const T& x)
		{
			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* next = pos._node->_next;
			Node* prev = pos._node->_prev;
			next->_prev = prev;
			prev->_next = next;
			delete pos._node;
			--_size;

			return next;
		}
		void pop_back()
		{
			erase(--end());
		}
		void pop_front()
		{
			erase(begin());
		}
	private:
		Node* _head;
		size_t _size;
	};
}

结语

以上我们就讲完了list的用法以及模拟实现，希望对大家有所帮助，感谢大家的阅读，欢迎大家批评指正！

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

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

相关文章

window 中安装 php 环境

window 中安装 php 环境

window 中安装 php 环境 一、准备二、下载三、安装四、测试 一、准备 安装前需要安装 Apache &#xff0c;可以查看这篇博客。 二、下载 先到这里下载 这里选择版本为“VS16 x64 Thread Safe”&#xff0c;这个版本不要选择线程安全的&#xff0c;我试过&#xff0c;会缺少文…
阅读更多...
【大模型】LLaMA: Open and Efficient Foundation Language Models

【大模型】LLaMA: Open and Efficient Foundation Language Models

链接&#xff1a;https://arxiv.org/pdf/2302.13971 论文&#xff1a;LLaMA: Open and Efficient Foundation Language Models Introduction 规模和效果 7B to 65B&#xff0c;LLaMA-13B 超过 GPT-3 (175B)Motivation 如何最好地缩放特定训练计算预算的数据集和模型大小&…
阅读更多...
流程图图解@RequestBody @RequestPart @RequestParam @ModelAttribute

流程图图解@RequestBody @RequestPart @RequestParam @ModelAttribute

RequestBody 只能用一次&#xff0c;因为只有一个请求体 #mermaid-svg-8WZfkzl0GPvOiNj3 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-8WZfkzl0GPvOiNj3 .error-icon{fill:#552222;}#mermaid-svg-8WZfkzl0GPvOiNj…
阅读更多...
论文阅读--supervised learning with quantum enhanced feature spaces

论文阅读--supervised learning with quantum enhanced feature spaces

简略摘要 量子算法实现计算加速的核心要素是通过可控纠缠和干涉利用指数级大的量子态空间。本文在超导处理器上提出并实验实现了两种量子算法。这两种方法的一个关键组成部分是使用量子态空间作为特征空间。只有在量子计算机上才能有效访问的量子增强特征空间的使用为量子优势提…
阅读更多...
django+boostrap实现注册

django+boostrap实现注册

一、django介绍 Django 是一个高级的 Python 网络框架&#xff0c;可以快速开发安全和可维护的网站。由经验丰富的开发者构建&#xff0c;Django 负责处理网站开发中麻烦的部分&#xff0c;因此你可以专注于编写应用程序&#xff0c;而无需重新开发。 它是免费和开源的&#x…
阅读更多...
【面试题】接口怎么测试？如何定位前后端的Bug？

【面试题】接口怎么测试？如何定位前后端的Bug？

接口怎么测试&#xff1f; 接口测试用来验证不同软件组件之间的交互是否正常。包括验证数据传输&#xff0c;参数传递&#xff0c;我在多个项目中有过测试接口的经验。&#xff08;… 当进行接口测试时&#xff0c;会使用Postman和Python的Requests库。首先根据接口文档设计测…
阅读更多...
151页PDF | XX集团数字化转型SAP项目规划方案（限免下载）

151页PDF | XX集团数字化转型SAP项目规划方案（限免下载）

一、前言 这份报告是XX集团数字化转型SAP项目规划方案&#xff0c;该报告涵盖了集团战略解读、管理痛点分析、信息化建设目标、整体架构方案、实施策略、SAP系统价值和预期收益&#xff0c;旨在通过数字化推动集团运营模式变革&#xff0c;实现降本增效和价值创新。 《XX集团…
阅读更多...
iOS逆向入门：使用theos注入第三方依赖库

iOS逆向入门：使用theos注入第三方依赖库

背景 theos是一个跨平台的软件开发框架&#xff0c;常用于管理&#xff0c;开发和部署iOS项目&#xff0c;同时也是开发iOS越狱插件的主要工具。和MonkeyDev不同的是&#xff0c;它不依赖于xcode&#xff0c;可以在多个操作系统上运行。一个完整的iOS越狱开发流程包括&#xf…
阅读更多...
LLM文档对话 —— pdf解析关键问题

LLM文档对话 —— pdf解析关键问题

一、为什么需要进行pdf解析&#xff1f; 最近在探索ChatPDF和ChatDoc等方案的思路&#xff0c;也就是用LLM实现文档助手。在此记录一些难题和解决方案&#xff0c;首先讲解主要思想&#xff0c;其次以问题回答的形式展开。 二、为什么需要对pdf进行解析&#xff1f; 当利用L…
阅读更多...
HarmonyOS Next 浅谈 发布-订阅模式

HarmonyOS Next 浅谈 发布-订阅模式

HarmonyOS Next 浅谈 发布-订阅模式 前言 其实在目前的鸿蒙应用开发中&#xff0c;或者大前端时代、vue、react、小程序等等框架、语言开发中&#xff0c;普通的使用者越来越少的会碰到必须要掌握设计模式的场景。大白话意思就是一些框架封装太好了&#xff0c;使用者只管在它…
阅读更多...
【HCIP]——OSPF综合实验

【HCIP]——OSPF综合实验

题目 实验需求 根据上图可得&#xff0c;实验需求为&#xff1a; 1.R5作为ISP&#xff1a;其上只能配置IP地址&#xff1b;R4作为企业边界路由器&#xff0c;出口公网地址需要通过PPP协议获取&#xff0c;并进行CHAP认证。&#xff08;PS&#xff1a;因PPP协议尚未学习&#…
阅读更多...
利用大语言模型对基准数据集在预处理和微调过程的数据污染检测

利用大语言模型对基准数据集在预处理和微调过程的数据污染检测

概述 虽然大规模语言模型发展迅速&#xff0c;但对其进行评估却变得越来越困难。人们在短时间内建立了许多基准来评估大规模语言模型的性能&#xff0c;但这些分数并不一定反映真实世界的性能。此外&#xff0c;还有人指出&#xff0c;这些基准数据集可能受到预处理和微调过程…
阅读更多...
【SKFramework框架】一、框架介绍

【SKFramework框架】一、框架介绍

推荐阅读 CSDN主页GitHub开源地址Unity3D插件分享QQ群&#xff1a;398291828小红书小破站 大家好&#xff0c;我是佛系工程师☆恬静的小魔龙☆&#xff0c;不定时更新Unity开发技巧&#xff0c;觉得有用记得一键三连哦。 一、前言 【Unity3D框架】SKFramework框架完全教程《全…
阅读更多...
Linux中定时操作

Linux中定时操作

一、一次性定时 这里以23&#xff1a;00为例 输入相关时间----at 23&#xff1a;00 所保存在哪个文件里------ ls /root > at.txt <EOT> &#xff08;ctrld退出到root&#xff09; 查看计划任务 ------ at -l 最后删除任务----at -d 2 二、周期性定时&#xf…
阅读更多...
自回归和Rectified Flow完美融合统一多模态理解和生成！DeepSeek北大等开源JanusFlow

自回归和Rectified Flow完美融合统一多模态理解和生成！DeepSeek北大等开源JanusFlow

论文链接&#xff1a;https://arxiv.org/pdf/2411.07975 github链接&#xff1a;https://github.com/deepseek-ai/Janus 亮点直击 统一多模态框架&#xff1a; 提出 JanusFlow&#xff0c;一个同时处理图像理解和文本到图像生成任务的统一模型&#xff0c;解决了任务分离带来的…
阅读更多...
Docker1：认识docker、在Linux中安装docker

Docker1：认识docker、在Linux中安装docker

欢迎来到“雪碧聊技术”CSDN博客&#xff01; 在这里&#xff0c;您将踏入一个专注于Java开发技术的知识殿堂。无论您是Java编程的初学者&#xff0c;还是具有一定经验的开发者&#xff0c;相信我的博客都能为您提供宝贵的学习资源和实用技巧。作为您的技术向导&#xff0c;我将…
阅读更多...
数据结构在二叉树Oj中利用子问题思路来解决问题

数据结构在二叉树Oj中利用子问题思路来解决问题

二叉树Oj题 获取二叉树的节点数获取二叉树的终端节点个数获取k层节点的个数获取二叉树的高度检测为value的元素是否存在判断两颗树是否相同判断是否是另一棵的子树反转二叉树判断一颗二叉树是否是平衡二叉树时间复杂度O(n*n)复杂度O(N) 二叉树的遍历判断是否是对称的二叉树二叉…
阅读更多...
【C++】踏上C++学习之旅（九）：深入“类和对象“世界，掌握编程的黄金法则（四）（包含四大默认成员函数的练习以及const对象）

【C++】踏上C++学习之旅（九）：深入“类和对象“世界，掌握编程的黄金法则（四）（包含四大默认成员函数的练习以及const对象）

文章目录 前言1. 实现Date类的构造函数2. 实现Date类的拷贝构造函数3. 实现Date类的赋值运算符重载4. 实现各Date对象之间的比较接口5. 实现Date对象的加减接口6. const成员7. 取地址及const取地址操作符重载 前言 在我们前面学习到了"类和对象"的四大默认成员函数(…
阅读更多...
远程控制软件使用教程

远程控制软件使用教程

随着数字化办公浪潮的席卷&#xff0c;远程控制软件已经悄无声息地融入我们的日常生活&#xff0c;成为提升工作效率的神奇工具。它让我们无论身处何地&#xff0c;都能轻松驾驭办公室电脑&#xff0c;让旅途中的工作也变得轻松自如。那么&#xff0c;远程控制软件究竟是什么&a…
阅读更多...
oracle查看锁阻塞-谁阻塞了谁

oracle查看锁阻塞-谁阻塞了谁

一 模拟锁阻塞 #阻塞1 一个会话正在往一个大表写入大量数据的时候&#xff0c;另一个会话加字段&#xff1a; #会话1 #会话2 会话2被阻塞了。 #阻塞2 模拟一个会话update一条记录&#xff0c;没提交。 另一个会话也update这一条记录&#xff1a; 会话2被阻塞了。 二 简单查…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023