C++第二十五弹---从零开始模拟STL中的list(下)

news2025/1/22 9:15:32

 ✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】【C++详解】

目录

1、函数补充

2、迭代器完善

3、const迭代器

总结

1、函数补充

拷贝构造

思路：

  • 先构造一个头结点，然后将 lt 类中的元素依次尾插到新的结点上。
void empty_init()
{
	_head = new Node;
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}
list(const list<T>& lt)
{
	empty_init();//构造一个头结点
	for (auto& x : lt)
	{
		push_back(x);
	}
}

 {}初始化构造

思路：

  • 先构造一个头结点，然后将 il 类中的元素依次尾插到新的结点上。
list(initializer_list<T> il)
{
	empty_init();
	for (auto& x : il)
	{
		push_back(x);
	}
}

赋值操作符重载

void swap(list<T>& lt)
{
	std::swap(_head, lt._head);
	std::swap(_size, lt._size);
}
list<T>& operator=(list<T> lt)
{
	swap(lt);
	return *this;
}

大小相关函数

size_t size()
{
	return _size;
}
bool empty()
{
	return _size == 0;
}

clear()

清空list的内容，保留头结点。

//清空数据
void clear()
{
	iterator it = begin();
	while (it != end())
	{
		it = erase(it);//更新迭代器
	}
}

~list()

析构函数，清空list的内容并释放头结点。

~list()
{
	clear();//清空内容函数
	delete _head;//释放头结点
	_head = nullptr;//置空
}

2、迭代器完善

前面我们处理的都是内置类型的情况，如果我们出现自定义类型，如何解决？

自定义类型举例：

struct A
{
	int _a1;
	int _a2;
	A(int a1 = 0, int a2 = 0)
		:_a1(a1)
		, _a2(a2)
	{}
};

 首先我们先看看几种自定义类型的尾插方式:

void test_list3()
{
	list<A> lt;
	A aa1(1, 1);//实例化对象
	A aa2{ 2,2 };//多参数的隐式类型转换，C++11

	lt.push_back(aa1);//有名对象实例化
	lt.push_back(aa2);
	lt.push_back(A(3, 3));//匿名对象
	lt.push_back({ 4,4 });//多参数的隐式类型转换，C++11
}

 对自定义类型进行遍历：

list<A>::iterator it = lt.begin();
while (it != lt.end())
{
	cout << *it << " ";//自定义类型输出不了
	it++;
}
cout << endl;

A是自定义类型，不支持留插入，我们解引用得到的_data是A的对象 。在结构体中我们获取到自定义类型的对象可以通过 . 进行访问内部成员，此处我们也可以使用 . 进行访问内部成员。

cout << (*it)._a1 << ":" << (*it)._a2 << " ";

但是如果这么使用会有一点别捏，我们在自定义类型中，也可以通过自定义类型的地址来访问成员，即通过 ->访问，此处我们也可以通过 ->进行访问，因此我们需要重载一个operator->()函数 。

迭代器类中重载operator->

T* operator->()
{
    return &_node->_data;//取数据的地址
}

使用->访问元素

cout << it->_a1 << ":" << it->_a2 << " ";

使用重载函数版

cout << it.operator->()->_a1 << ":" << it.operator->()->_a2 << " ";

测试结果：

注意：

这里隐藏了一个箭头，一个是重载，一个是原生指针的访问操作。

当重载 operator->，不会直接返回成员的值，而是应该返回一个指针，这个指针指向的对象包含我们想要访问的成员。当使用 ->运算符时，C++ 会自动和透明地调用重载的 operator-> 并继续 “链式” 访问成员，而不需要程序员显示地添加多余的箭头。 

3、const迭代器

 我们上一弹写的普通迭代器对于const对象是无法编译成功的，const不能调用非const成员函数(权限放大)。

下面我们则实现一个const迭代器的类。

与普通迭代器类似，我们需要先在list类中重命名一个const迭代器

typedef ListConstIterator<T> const_iterator;//const迭代器类

const_iterator begin() const
{
	return const_iterator(_head->_next);//匿名对象
	//return _head->_next;//单参数类型转换
}
const_iterator end() const
{
	return const_iterator(_head);
}

注意：

const迭代器名字不能写成 const iterator，因为const迭代器的本质是迭代器指向的内容不能修改，而不是迭代器本身不能修改，const_iterator这样定义是迭代器不能修改，内容还是可以修改的

实现const_iterator类有两种方式，如下：

方式一(单独实现一个新的类，修改普通迭代器的部分地方)：

template<class T>
struct ListConstIterator
{
	typedef ListConstIterator<T> Self;//对迭代器类重定义

	typedef ListNode<T> Node;
	Node* _node;

	//构造
	ListConstIterator(Node* node)
		:_node(node)
	{}

	const T& operator*()//只能访问，不能修改值
	{
		return _node->_data;
	}
	const T* operator->()
	{
		return &_node->_data;//返回指针
	}
	//前置++ 
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	//后置++
	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->_next;
		return *this;
	}
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}
	bool operator!=(const Self& it)
	{
		return _node != it._node;
	}
	bool operator==(const Self& it)
	{
		return _node == it._node;
	}
};

我们可以看到，const迭代器与普通迭代器的区间只在operator*与operator->的返回的类型上，那么我们是不是可以将两个类封装成一个模板类呢？？？

//普通迭代器和const迭代器只有两个返回值不同，因此我们使用模板封装
template<class T, class Ref, class Ptr>//reference引用 point指针
struct ListIterator
{
	typedef ListIterator<T, Ref, Ptr> Self;//对迭代器类重定义

	typedef ListNode<T> Node;
	Node* _node;

	//构造
	ListIterator(Node* node)
		:_node(node)
	{}

	//T& operator*()//遍历及修改
	Ref operator*()
	{
		return _node->_data;
	}
	//T* operator->()
	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& it)
	{
		return _node != it._node;
	}
	bool operator==(const Self& it)
	{
		return _node == it._node;
	}
};

合并之后的三个类模板参数：

  • T：链表结点存储_data值的数据类型
  • Ref：通过迭代器访问数据时的返回类型，可以是T&或者const T&。
  • Ptr：通过迭代器访问数据的指针类型，可以是T*或者const T*。

链表实例化如下：

typedef ListIterator<T, T&, T*> iterator;//普通迭代器类

typedef ListIterator<T, const T&, const T*> const_iterator;//const迭代器类

 list实现全部代码

namespace lin
{
	//链表基本结构
	template<class T>
	struct ListNode
	{
		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _data;

		ListNode(const T& val = T())//初始化值构造
			:_prev(nullptr)
			,_next(nullptr)
			,_data(val)
		{}

	};
	//原版普通迭代器
	//迭代器操作类 方法都要被访问，使用struct
	//template<class T>
	//struct ListIterator
	//{
	//	typedef ListIterator<T> Self;//对迭代器类重定义

	//	typedef ListNode<T> Node;
	//	Node* _node;

	//	//构造
	//	ListIterator(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 *this;
	//	}
	//	bool operator!=(const Self& it)
	//	{
	//		return _node != it._node;
	//	}
	//	bool operator==(const Self& it)
	//	{
	//		return _node == it._node;
	//	}
	//};

	//原版const迭代器
	//template<class T>
	//struct ListConstIterator
	//{
	//	typedef ListConstIterator<T> Self;//对迭代器类重定义

	//	typedef ListNode<T> Node;
	//	Node* _node;

	//	//构造
	//	ListConstIterator(Node* node)
	//		:_node(node)
	//	{}

	//	const T& operator*()//只能访问，不能修改值
	//	{
	//		return _node->_data;
	//	}
	//	const T* operator->()
	//	{
	//		return &_node->_data;//返回指针
	//	}
	//	//前置++ 
	//	Self& operator++()
	//	{
	//		_node = _node->_next;
	//		return *this;
	//	}
	//	//后置++
	//	Self operator++(int)
	//	{
	//		Self tmp(*this);
	//		_node = _node->_next;
	//		return *this;
	//	}
	//	Self& operator--()
	//	{
	//		_node = _node->_prev;
	//		return *this;
	//	}
	//	Self operator--(int)
	//	{
	//		Self tmp(*this);
	//		_node = _node->_prev;
	//		return tmp;
	//	}
	//	bool operator!=(const Self& it)
	//	{
	//		return _node != it._node;
	//	}
	//	bool operator==(const Self& it)
	//	{
	//		return _node == it._node;
	//	}
	//};

	//普通迭代器和const迭代器只有两个返回值不同，因此我们使用模板封装
	template<class T, class Ref, class Ptr>//reference引用 point指针
	struct ListIterator
	{
		typedef ListIterator<T,Ref,Ptr> Self;//对迭代器类重定义

		typedef ListNode<T> Node;
		Node* _node;

		//构造
		ListIterator(Node* node)
			:_node(node)
		{}

		//T& operator*()//遍历及修改
		Ref operator*()
		{
			return _node->_data;
		}
		//T* operator->()
		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& it)
		{
			return _node != it._node;
		}
		bool operator==(const Self& it)
		{
			return _node == it._node;
		}
	};

	
	template<class T>
	class list
	{
		typedef ListNode<T> Node;//将链表结构重命名

	public:
		//普通版本
		//typedef ListIterator<T> iterator;//需要被访问，放在public内

		//typedef ListConstIterator<T> const_iterator;//const迭代器类

		//类模板
		typedef ListIterator<T,T&,T*> iterator;//需要被访问，放在public内

		typedef ListIterator<T,const T&,const T*> const_iterator;//const迭代器类

		//构造哨兵结点
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}

		list()//默认构造
		{
			empty_init();//创建哨兵头结点
		}
		size_t size()
		{
			return _size;
		}
		void clear()//清空数据，不销毁哨兵头结点
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		~list()//析构函数
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		list(const list<T>& lt)//拷贝构造
		{
			empty_init();//创建头结点，然后进行尾插
			for (auto& x : lt)
			{
				push_back(x);
			}
		}
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		iterator begin() 
		{
			return iterator(_head->_next);//匿名对象
			//return _head->_next;//单参数类型转换
		}
		iterator end() 
		{
			return iterator(_head);
		}
		//解决打印修改值问题
		const_iterator begin() const
		{
			return const_iterator(_head->_next);//匿名对象
			//return _head->_next;//单参数类型转换
		}
		const_iterator end() const
		{
			return const_iterator(_head);
		}

		//单独实现的尾插
		//void push_back(const T& val)
		//{
		//	//tail 
		//	Node* newnode = new Node(val);
		//	Node* tail = _head->_prev;

		//	tail->_next = newnode;
		//	newnode->_prev = tail;
		//	newnode->_next = _head;
		//	_head->_prev = newnode;
		//}
		
		void insert(iterator pos, const T& val)//在pos位置前插入val
		{
			Node* cur = pos._node;
			Node* newnode = new Node(val);
			Node* prev = cur->_prev;

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

			_size++;
		}
		iterator erase(iterator pos)//删除pos位置，防止迭代器失效，返回迭代器后一个位置
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			//prev next
			prev->_next = next;
			next->_prev = prev;
			delete cur;
			_size--;
			return iterator(next);
		}
		//调用insert函数
		void push_back(const T& val)
		{
			//insert(--begin(),val);//不能使用+n，在--begin前面插入
			insert(end(), val);//end()前面
		}
		void push_front(const T& val)
		{
			insert(begin(), val);//begin()前面插入
		}
		void pop_back()
		{
			erase(--end());//end()前面删除
		}
		void pop_front()
		{
			erase(begin());//begin()位置删除
		}
	private:
		Node* _head;//链表成员变量
		size_t _size;//链表大小
	};
}

总结


本篇博客就结束啦，谢谢大家的观看，如果公主少年们有好的建议可以留言喔，谢谢大家啦！

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

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

相关文章

使用亮数据代理IP爬取PubMed文章链接和邮箱地址

使用亮数据代理IP爬取PubMed文章链接和邮箱地址

&#x1f482; 个人网站:【 摸鱼游戏】【神级代码资源网站】【工具大全】&#x1f91f; 一站式轻松构建小程序、Web网站、移动应用&#xff1a;&#x1f449;注册地址&#x1f91f; 基于Web端打造的&#xff1a;&#x1f449;轻量化工具创作平台&#x1f485; 想寻找共同学习交…
阅读更多...
2024上海初中生古诗文大会倒计时4个多月：单选题真题和独家解析

2024上海初中生古诗文大会倒计时4个多月：单选题真题和独家解析

现在距离2024年初中生古诗文大会还有4个多月时间&#xff0c;我们继续来看10道选择题真题和详细解析&#xff0c;以下题目截取自我独家制作的在线真题集&#xff0c;都是来自于历届真题&#xff0c;去重、合并后&#xff0c;每道题都有参考答案和解析。 为帮助孩子自测和练习&…
阅读更多...
Html/HTML5常用标签的学习

Html/HTML5常用标签的学习

课程目标 项目实战&#xff0c;肯定就需要静态网页。朝着做项目方式去学习静态网页。 01、编写第一个html工程结构化 cssjsimages/imgindex.html 归档存储和结构清晰就可以。 02、HTML标签分类 认知&#xff1a;标签为什么要分类&#xff0c;原因因为&#xff1a;分门别类…
阅读更多...
【经验】Ubuntu上离线安装VsCode插件浏览Linux kernel源码

【经验】Ubuntu上离线安装VsCode插件浏览Linux kernel源码

1、下载VsCode离线安装包 1.1 下载 下载地址：https://marketplace.visualstudio.com/vscode 本人安装的插件： C/C++ checkpatch Chinese clangd kconfig Makefile Tools Perl Perl Toolbox注意：C/C++插件要安装Linux 64版本 1.2 安装 将离线安装包拷贝到Ubuntu中，执…
阅读更多...
Opencv 色彩空间

Opencv 色彩空间

一 核心知识 色彩空间变换&#xff1b; 像素访问&#xff1b; 矩阵的、-、*、、&#xff1b; 基本图形的绘制 二 颜色空间 RGB&#xff1a;人眼的色彩空间&#xff1b; OpenCV默认使用BGR&#xff1b; HSV/HSB/HSL; YUV(视频); 1 RGB 2 BGR 图像的多种属性 1 访问图像(Ma…
阅读更多...
【CS.CN】优化HTTP传输：揭示Transfer-Encoding: chunked的奥秘与应用

【CS.CN】优化HTTP传输：揭示Transfer-Encoding: chunked的奥秘与应用

文章目录 0 序言0.1 由来0.2 使用场景 1 Transfer-Encoding: chunked的机制2 语法 && 通过设置Transfer-Encoding: chunked优化性能3 总结References 0 序言 0.1 由来 Transfer-Encoding头部字段在HTTP/1.1中被引入&#xff0c;用于指示数据传输过程中使用的编码方式…
阅读更多...
赚钱而已，你又不是宠物，干嘛让所有人都喜欢你？

赚钱而已，你又不是宠物，干嘛让所有人都喜欢你？

* 大家好&#xff0c;我是前端队长。前端程序员&#xff0c;2023年开始玩副业。做过AI绘画&#xff0c;公众号 AI 爆文&#xff0c;AI代写项目&#xff0c;累计变现五位数。 — 今天看到一句话说的真好&#xff1a; 太多人总想让别人喜欢自己了。有什么用&#xff0c;你又不是宠…
阅读更多...
C++的线性回归模型

C++的线性回归模型

线性回归模型是数理统计中的一种回归分析方法&#xff0c;其核心思想是通过建立一个线性方程来描述因变量与自变量之间的关系。这种关系可以表示为y wx e&#xff0c;其中y是因变量&#xff0c;x是自变量&#xff0c;w是回归系数向量&#xff0c;e是误差项&#xff0c;服从均…
阅读更多...
【TB作品】MSP430F5529 单片机，简单电子琴

【TB作品】MSP430F5529 单片机，简单电子琴

使用MSP430制作一个简单电子琴 作品功能 这个项目基于MSP430单片机&#xff0c;实现了一个简单的电子琴。通过按键输入&#xff0c;电子琴可以发出对应的音符声音。具体功能包括&#xff1a; 按下按键时发出对应音符的声音。松开按键时停止发声。支持C调低音、中音和高音。 …
阅读更多...
抖抖分析师和抖音分析有什么区别？

抖抖分析师和抖音分析有什么区别？

"抖抖分析师"和"抖音分析"虽然都与抖音这个平台有关&#xff0c;但是二者的含义有很大的区别。 首先&#xff0c;抖抖分析师通常指的是专门对抖音平台进行各种数据分析、用户行为研究、内容趋势预测等工作的人员。他们可能会洞察用户在抖音上的行为习惯&a…
阅读更多...
OpenAI模型规范概览

OpenAI模型规范概览

这是OpenAI对外分享的模型规范文档&#xff08;Model Spec&#xff09;&#xff0c;它定义了OpenAI希望在API接口和ChatGPT&#xff08;含GPT系列产品&#xff09;中模型的行为方式&#xff0c;这也是OpenAI超级对齐团队奉行的行为准则&#xff0c;希望能对国内做RLHF的同学有帮…
阅读更多...
Soildworks学习笔记（一）

Soildworks学习笔记（一）

1.如何添加M3,M4等螺丝孔&#xff1a; 有时候异形孔向导显示灰色是因为没有退出草图选项卡&#xff0c;选择异形孔向导就可以进行异形孔的设定和放置&#xff1a; solidwork放置螺丝孔以及显示螺纹的问题_.16-m3 solidwork-CSDN博客 2.如何修剪线条&#xff1a; 如何倒圆角或…
阅读更多...
“薅羊毛”到被“割韭菜”，警惕网络副业陷井

“薅羊毛”到被“割韭菜”，警惕网络副业陷井

本想“薅羊毛”却被“割韭菜”&#xff0c;这些现象在网络副业领域中尤为常见。许多人寻求在网络上开展副业以增加收入&#xff0c;但往往因为缺乏足够的警惕和了解&#xff0c;而陷入各种陷阱和风险中。 “薅羊毛”在副业领域通常指的是利用平台优惠、漏洞或规则&#xff0c;…
阅读更多...
操作系统的启动过程和初始化

操作系统的启动过程和初始化

参考来源&#xff1a; Linux的启动过程&#xff0c;作者&#xff1a;阮一峰 第一步、加载内核 操作系统接管硬件以后&#xff0c;首先读入 /boot 目录下的内核文件。 rootub1804:/boot# ls -l 总用量 120636 -rw-r--r-- 1 root root 237767 5月 19 2023 config-5.4.0-15…
阅读更多...
数据结构--实验

数据结构--实验

话不多说&#xff0c;直接启动&#xff01;&#x1f44c;&#x1f923; 目录 一、线性表&#x1f60e; 1、建立链表 2、插入元素 3、删除特定位置的元素 4、输出特定元素值的位置 5、输出特定位置的元素值 6、输出整个链表 实现 二、栈和队列&#x1f618; 栈 顺序栈 …
阅读更多...
LeetCode | 1470.重新排列数组

LeetCode | 1470.重新排列数组

class Solution(object):def shuffle(self, nums, n):""":type nums: List[int]:type n: int:rtype: List[int]"""result []for i in range(n):result.append(nums[i])result.append(nums[i n])return result这题很容易想到的就是遍历整个数组…
阅读更多...
HQL面试题练习 —— 累加刚好超过各省GDP40%的地市名称

HQL面试题练习 —— 累加刚好超过各省GDP40%的地市名称

目录 1 题目2 建表语句3 题解 1 题目 现有各省地级市的gdp数据&#xff0c;求从高到底累加刚好超过各省GDP40%的地市名称&#xff0c;临界地市也需要。例如&#xff1a; 浙江省的杭州24% 宁波 20% ,杭州宁波44% 大于40% 取出杭州、宁波 江苏省的苏州19% 南京 14% 无锡 12%&am…
阅读更多...
天行健咨询 | 谢宁DOE培训的课程内容有哪些？

天行健咨询 | 谢宁DOE培训的课程内容有哪些？

谢宁DOE培训的课程内容丰富而深入&#xff0c;旨在帮助学员掌握谢宁问题解决方法在质量管理中的重要作用&#xff0c;并学会如何运用这一方法工具&#xff0c;在不中断生产过程的前提下&#xff0c;找出并解决生产中遇到的复杂而顽固的问题。 首先&#xff0c;课程会详细介绍谢…
阅读更多...
国产神器，这个太强悍了 !

国产神器，这个太强悍了 !

自从 ChatGPT 火了以后&#xff0c;国内的 AI 大模型也是越来越多&#xff0c;各家都有不同的侧重点&#xff0c;其中&#xff0c;咱们国家队的代表就是阿里的通义千问了。就在今天&#xff0c;通义千问推出了第二代开源模型系列Qwen2&#xff0c;下面跟大家重点介绍一下这个新…
阅读更多...
【面试干货】索引的优缺点

【面试干货】索引的优缺点

【面试干货】索引的优缺点 1、创建索引可以大大提高系统的性能&#xff08;**优点**&#xff09;2、增加索引也有许多不利的方面&#xff08;**缺点**&#xff09; &#x1f496;The Begin&#x1f496;点点关注&#xff0c;收藏不迷路&#x1f496; 1、创建索引可以大大提高系…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023