[C++] 模拟实现list（二）

news2024/9/9 8:07:40

标题：[C++] 模拟实现list（二）

@水墨不写bug

目录

（一）回顾

（二）迭代器类的封装设计

（1）成员函数简要分析

 （2）const迭代器类的设计

（3）list类的封装设计

（4）反向迭代器类的设计

（三）实现list类

正文开始：

（一）回顾

        本篇文章接续《[C++] 模拟实现list（二）》继续讲解STL实现list的逻辑和思考，最终提供实现的list的最终版本。

        [C++] 模拟实现list（二）中，我们定义了三个类：

template<typename T>
struct ListNode;

template<typename T>
struct ListIterator;

template<class T>
class list;

        ListNode即是list的一个节点；ListIterator即对节点的指针的封装的一个类，也就是迭代器；list即是链表的类；

         我们一般通过指针来维护链表，但是如果直接拿指针这个内置类型作为迭代器，迭代器的行为不符合我们的要求，所以我们将这个指针封装为一个类，这样就可以通过类的成员函数重载运算符来使得迭代器的行为符合我们的要求。

（二）迭代器类的封装设计

（1）成员函数简要分析

        我们实现迭代器类ListIterator，本质就是通过封装节点的指针，来实现要求的功能。这个迭代器类，看似是一个自定义类，其实我们可以把它的行为等效的看为一个指针类型：

        指针的前置++，就是节点指针先向后移动再使用。

        指针的前置--，就是节点指针的先向前移动，再使用。

        指针的后置++，后置--，先使用，再移动。

        指针的解引用，就得到了数据——然而对于封装的类，我们把它的行为定义为返回节点指针的数据。

        变量引用返回，得到这个变量本身——对于ListIterator类，我们返回数据T的引用；

        以及对==和 != 的重载，只需要比较节点指针内的数据是否一致即可。

 （2）const迭代器类的设计

        有普通的迭代器，就会有const迭代器，我们根据上面的分析，可以实现的普通迭代器如下：

template<typename T>
struct ListIterator
{
	typedef ListNode<T> Node;
	typedef ListIterator<T> Self;
	ListIterator(Node* node = nullptr)
		:_node(node)
	{}
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	Self& operator++(int)
	{
		Self tem(*this);
		_node = _node->_next;
		return tem;
	}
	Self& operator--(int)
	{
		Self tem(*this);
		_node = _node->_prev;
		return *this;
	}
	T& operator*()
	{
		return _node->_data;
	}
	T* operator->()
	{
		return &(_node->_data);
	}
	bool operator==(const Self& ltt)
	{
		return _node == ltt._node;
	}
	bool operator!=(const Self& ltt)
	{
		return !(*this == ltt);
	}
	 Node* _node;
};

        如果第一次思考，你可能会想到直接在实例化的时候在普通迭代器前面加上const，但是这是错误的做法：如果直接在普通迭代器前面加上const，这就表明const修饰迭代器本身（类本身，也就是类对象本身不能修改：由于类内部只有一个节点的指针类型，所以这个指针本身不能修改，这是一个与事实相悖的结果：指针不能移动了！）

        想要解决上述问题，我们只有再定义一个类ConstListIterator，在类内部我们发现其实现与普通迭代器相比，只有两个不同的地方：

        这两个地方自然是涉及对象内数据的成员函数重载，他们是：

operator*()

operator->()

         如果我们执意要实现ConstListIterator类，可以实现如下：

template<typename T>
struct ListIterator
{
	typedef ListNode<T> Node;
	typedef ListIterator<T> Self;
	ListIterator(Node* node = nullptr)
		:_node(node)
	{}
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	Self& operator++(int)
	{
		Self tem(*this);
		_node = _node->_next;
		return tem;
	}
	Self& operator--(int)
	{
		Self tem(*this);
		_node = _node->_prev;
		return *this;
	}
	const T& operator*()
	{
		return _node->_data;
	}
	const T* operator->()
	{
		return &(_node->_data);
	}
	bool operator==(const Self& ltt)
	{
		return _node == ltt._node;
	}
	bool operator!=(const Self& ltt)
	{
		return !(*this == ltt);
	}
	 Node* _node;
};

通过比较两个类，我们发现只有他们的返回值不同而已，这两个类的大部分代码都是重复的。那么有没有一种方法可以缩减代码量，减少我们的工作量呢？

        我们可以通过额外多传入两个参数Ptr，Ref来解决这个问题：

template<typename T,class Ref,class Ptr>
struct ListIterator
{
	typedef ListNode<T> Node;
	typedef ListIterator<T, Ref, Ptr> Self;
	ListIterator(Node* node = nullptr)
		:_node(node)
	{}
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	Self& operator++(int)
	{
		Self tem(*this);
		_node = _node->_next;
		return tem;
	}
	Self& operator--(int)
	{
		Self tem(*this);
		_node = _node->_prev;
		return *this;
	}
	T& operator*()
	{
		return _node->_data;
	}
	Ref operator*() const
	{
		return _node->_data;
	}
	T* operator->()
	{
		return &(_node->_data);
	}
	Ptr operator->() const
	{
		return &(_node->_data);
	}
	bool operator==(const Self& ltt)
	{
		return _node == ltt._node;
	}
	bool operator!=(const Self& ltt)
	{
		return !(*this == ltt);
	}

	 Node* _node;
};

        由于const迭代器与普通迭代器的大部分行为都是类似的，只有上述两个重载函数的返回值不同，这意味着const迭代器的*和->的返回值不能修改，是一个常量，这于事实相符。

        所以我们的第一个模板参数相同。都是T，而第二与第三个模板参数则根据迭代器类型的不同而不同：如果实例化的对象是const迭代器，则传入的Ref接受的是const T&，Ptr接受的是const T* ，我们这样就通过一个类模板就可以实现ListIterator和ConstListIterator两种迭代器类型。

（3）list类的封装设计

        由于我们在设计迭代器类的时候，把整个类设置为了struct，可以公开访问，这意味着我们可以在list类中使用迭代器ListIterator，这是我们现前就考虑的。但是在STL中，整个容器的设计按照迭代器模式设计，将迭代器类统称为iterator，所以与STL保持一致，同时与我们的迭代器类相互嵌合，所以我们先typedef出迭代器和const迭代器；接下来对于list的实现，就是我们的老面孔了——实现双向带头循环链表，你可以参考我的这篇文章：《实现双向链表》——里面有非常详细的讲解。

        所以，在这里我们不再赘述实现双向链表的过程。

（4）反向迭代器类的设计

        反向迭代器与普通迭代器的实现基本一致，只是在++改为节点前移动；--改为节点后移动。

反向迭代器类实现如下：

template<typename T, class Ref, class Ptr>
struct ReverseListIterator
{
	typedef ListNode<T> Node;
	typedef ReverseListIterator<T, Ref, Ptr> Self;
	ReverseListIterator(Node* node = nullptr)
		:_node(node)
	{}
	Self& operator++()
	{
		_node = _node->_prev;
		return *this;
	}
	Self& operator--()
	{
		_node = _node->_next;
		return *this;
	}
	Self& operator++(int)
	{
		Self tem(*this);
		_node = _node->_prev;
		return tem;
	}
	Self& operator--(int)
	{
		Self tem(*this);
		_node = _node->_next;
		return *this;
	}
	T& operator*()
	{
		return _node->_data;
	}
	Ref operator*() const
	{
		return _node->_data;
	}
	T* operator->()
	{
		return &(_node->_data);
	}
	Ptr operator->() const
	{
		return &(_node->_data);
	}
	bool operator==(const Self& ltt)
	{
		return _node == ltt._node;
	}
	bool operator!=(const Self& ltt)
	{
		return !(*this == ltt);
	}

	Node* _node;
};

        需要注意的是，反向迭代器也有const类型，所以采用了和普通迭代器同样的处理方法：设置三个模板参数：<T，Ref，Ptr>

（三）实现list类

        源代码如下：

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

namespace ddsm
{
	template<typename T>
	struct ListNode
	{
		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _data;

		ListNode(const T& val = T())
			:_prev(nullptr)
			,_next(nullptr)
			,_data(val)
		{}
	};


	template<typename T,class Ref,class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		ListIterator(Node* node = nullptr)
			:_node(node)
		{}
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		Self& operator++(int)
		{
			Self tem(*this);
			_node = _node->_next;
			return tem;
		}
		Self& operator--(int)
		{
			Self tem(*this);
			_node = _node->_prev;
			return *this;
		}
		T& operator*()
		{
			return _node->_data;
		}
		Ref operator*() const
		{
			return _node->_data;
		}
		T* operator->()
		{
			return &(_node->_data);
		}
		Ptr operator->() const
		{
			return &(_node->_data);
		}
		bool operator==(const Self& ltt)
		{
			return _node == ltt._node;
		}
		bool operator!=(const Self& ltt)
		{
			return !(*this == ltt);
		}

		 Node* _node;
	};
	template<typename T, class Ref, class Ptr>
	struct ReverseListIterator
	{
		typedef ListNode<T> Node;
		typedef ReverseListIterator<T, Ref, Ptr> Self;
		ReverseListIterator(Node* node = nullptr)
			:_node(node)
		{}
		Self& operator++()
		{
			_node = _node->_prev;
			return *this;
		}
		Self& operator--()
		{
			_node = _node->_next;
			return *this;
		}
		Self& operator++(int)
		{
			Self tem(*this);
			_node = _node->_prev;
			return tem;
		}
		Self& operator--(int)
		{
			Self tem(*this);
			_node = _node->_next;
			return *this;
		}
		T& operator*()
		{
			return _node->_data;
		}
		Ref operator*() const
		{
			return _node->_data;
		}
		T* operator->()
		{
			return &(_node->_data);
		}
		Ptr operator->() const
		{
			return &(_node->_data);
		}
		bool operator==(const Self& ltt)
		{
			return _node == ltt._node;
		}
		bool operator!=(const Self& ltt)
		{
			return !(*this == ltt);
		}

		Node* _node;
	};


	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;
		typedef ReverseListIterator<T, T&, T*> reverse_iterator;
		typedef ReverseListIterator<T, const T&, const T*> const_reverse_iterator;
	public:
		//对于空链表的初始化（只创建一个头节点）
		void init_empty()
		{
			_pHead = new Node;
			_pHead->_next = _pHead;
			_pHead->_prev = _pHead;
		}
		//默认构造
		list()
		{
			init_empty();
		}
		// n 个值初始化
		list(int n, const T& value = T())
		{
			init_empty();
			for (size_t i = 0; i < n; i++)
			{
				push_back(value);
			}
		}
		//拷贝构造,深拷贝
		//list<int> l1(l2)
		list(const list<T>& lt)
		{
			init_empty();
			for (const auto& e : lt)
			{
				push_back(e);
			}
		}

		//赋值重载现代写法
		//复用拷贝构造
		void operator=(list<T> lt)
		{
			std::swap(_pHead,lt._pHead);
		}

		//初始化列表，初始化
		list(std::initializer_list<T> init)
		{
			init_empty();
			for (const auto& e : init)
			{
				push_back(e);
			}
		}


		void clear()
		{
			auto pos = begin();
			while (pos != end())
			{
				pos = erase(pos);//迭代器更新防止失效
			}
		}

		~list()
		{
			clear();
			delete _pHead;
			_pHead = nullptr;
		}
		/*void push_back(const T& value = T()) const
		{
			Node* newnode = new Node(value);

			newnode->_next = _pHead;
			newnode->_prev = _pHead->_prev;
			_pHead->_prev->_next = newnode;
			_pHead->_prev = newnode;
		}*/
		/*void push_back(const T& value)
		{
			Node* newnode = new Node(value);

			newnode->_next = _pHead;
			newnode->_prev = _pHead->_prev;
			_pHead->_prev->_next = newnode;
			_pHead->_prev = newnode;
		}*/

		reverse_iterator rbegin()
		{
			return reverse_iterator(_pHead->_prev);
		}
		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(_pHead->_prev);
		}
		reverse_iterator rend()
		{
			return reverse_iterator(_pHead);
		}
		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(_pHead);
		}
		iterator begin()
		{
			return iterator(_pHead->_next);
		}
		const_iterator begin() const
		{
			return const_iterator(_pHead->_next);
		}
		iterator end()
		{
			return iterator(_pHead);
		}
		const_iterator end() const
		{
			return const_iterator(_pHead);
		}
		//在指定位置之前插入
		iterator insert(iterator pos,const T& val = T())
		{
			Node* newnode = new Node(val);
			Node* cur = pos._node;
			Node* prev = cur->_prev;

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

			return iterator(newnode);
		}
		//删除指定位置的节点
		iterator erase(iterator pos)
		{
			assert(pos != end());

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

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

			delete cur;

			return iterator(next);
		}
		void push_front(const T& value)
		{
			insert(begin(), value);
		}
		void push_back(const T& value)
		{
			insert(end(), value);
		}
		void pop_front()
		{
			erase(begin());
		}
		void pop_back()
		{
			erase(--end());
		}
		T& front()
		{
			return begin()._node->_data;
		}
		const T& front()const
		{
			return begin()._node->_data;
		}
		T& back()
		{
			return (--end())._node->_data;
		}
		const T& back()const
		{
			return (--end())._node->_data;
		}
		size_t size()const
		{
			int count = 0;
			for (const auto& e : *this)
			{
				count++;
			}
			return count;
		}
		bool empty()const
		{
			return size() == 0;
		}
	private:
		Node* _pHead;
	};

}

完~

未经作者同意禁止转载

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

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

相关文章

国漫推荐08

国漫推荐08

仙侠、武侠、恋爱、战斗、现代、古风 1.《仙王的日常生活》仙侠、日常、搞笑 《仙王的日常生活》第一季 《仙王的日常生活 第二季》 《仙王的日常生活 第三季》 《仙王的日常生活 第四季》 2.《风灵玉秀》武侠、少女 3.刺客伍六七 番名季度上映时间《伍六七》第一季2018-04-…
阅读更多...
ppt如何翻译最高效？盘点5个便捷易用的ppt翻译器

ppt如何翻译最高效？盘点5个便捷易用的ppt翻译器

正值夏日炎炎&#xff0c;7.15初伏即将到来&#xff0c;天气更是开始热到让人无法专心工作~面对电脑上一堆非母语的PPT文件&#xff0c;看得人愈发烦躁。 幸运的是&#xff0c;我手里头常常备着几款ppt翻译工具&#xff0c;这才让办公显得没那么枯燥和烦闷~倘若你也遇上同样的…
阅读更多...
技术速递｜宣布为 .NET 升级助手提供第三方 API 和包映射支持

技术速递｜宣布为 .NET 升级助手提供第三方 API 和包映射支持

作者&#xff1a;Marco Goertz 排版&#xff1a;Alan Wang .NET 升级助手是一个 Visual Studio 扩展和命令行工具&#xff0c;可帮助您将应用从之前的 .NET 和 .NET Framework 升级到最新版本的 .NET。正如我们在之前的文章中所描述的那样&#xff0c;它为升级 Microsoft 库和框…
阅读更多...
vite+vue3创建cesium （ts/js）

vite+vue3创建cesium （ts/js）

在要创建项目的文件夹。输入cmd 1.搭建第一个Vite项目。 npm init vitelatest 安装Cesium插件 cesium插件&#xff1a;vite-plugin-cesium npm i cesium vite-plugin-cesium vite -D配置cesium 在vite.config.ts/vite.config.js文件中 import cesium from vite-plugin-ces…
阅读更多...
韦东山嵌入式linux系列-LED 驱动程序框架

韦东山嵌入式linux系列-LED 驱动程序框架

1 回顾字符设备驱动程序框架 图中驱动层访问硬件外设寄存器依靠的是 ioremap 函数去映射到寄存器地址&#xff0c;然后开始控制寄存器。 那么该如何编写驱动程序&#xff1f; ① 确定主设备号&#xff0c;也可以让内核分配&#xff1b;② 定义自己的 file_operations 结构体&…
阅读更多...
【D3.js in Action 3 精译】1.3 D3 视角下的数据可视化最佳实践（下）

【D3.js in Action 3 精译】1.3 D3 视角下的数据可视化最佳实践（下）

当前内容所在位置 第一部分 D3.js 基础知识 第一章 D3.js 简介 ✔️ 1.1 何为 D3.js&#xff1f;1.2 D3 生态系统——入门须知 1.2.1 HTML 与 DOM1.2.2 SVG - 可缩放矢量图形1.2.3 Canvas 与 WebGL1.2.4 CSS1.2.5 JavaScript1.2.6 Node 与 JavaScript 框架1.2.7 Observable 记事…
阅读更多...
Qt常用基础控件总结—旋转框部件(QSpinBox类和QDoubleSpinBox类)

Qt常用基础控件总结—旋转框部件(QSpinBox类和QDoubleSpinBox类)

旋转框(微调按钮)部件 QAbstractSpinBox 类 QAbstractSpinBox 类介绍 QAbstractSpinBox 类是 QWidget 类的直接子类，虽然该类不是抽象类，但该类并未提供实际的功能，仅为旋转框提供了一些外观的形式以及需要子类实现了成员，也就是说点击微调按钮的上/下按钮，不会使其中的…
阅读更多...
DID差分模型案例集（传统DID、队列DID、渐近DID、空间DID、PSM-DID）

DID差分模型案例集（传统DID、队列DID、渐近DID、空间DID、PSM-DID）

双重差分&#xff08;DID&#xff09;模型是一种广泛应用于经济学、社会学等领域的统计方法&#xff0c;主要用于评估政策或事件的因果效应。以下是DID模型几个重要变体的简要介绍&#xff1a; 1、传统DID&#xff08;Traditional DID&#xff09;&#xff1a;这是DID模型的基…
阅读更多...
Keepalived+HAProxy 集群及虚IP切换实践

Keepalived+HAProxy 集群及虚IP切换实践

1、软件介绍 ①Keepalived keepalive是一个用c语言编写的路由软件&#xff0c;这个项目的主要目标是为Linux系统和基于Linux的基础设施提供简单而健壮的负载平衡和高可用性设施。负载均衡框架依赖于众所周知且广泛使用的Linux Virtual Server (IPVS)内核模块提供第4层负载均衡…
阅读更多...
代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树

代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树

今日任务 669. 修剪二叉搜索树 题目链接&#xff1a; https://leetcode.cn/problems/trim-a-binary-search-tree/description/题目描述&#xff1a; Code class Solution { public:TreeNode* trimBST(TreeNode* root, int low, int high) {if(root nullptr){return root;…
阅读更多...
应力 (Stress) 是指单位面积上所承受的力

应力 (Stress) 是指单位面积上所承受的力

应力 (Stress) 是指单位面积上所承受的力 flyfish 轴向力 轴向力 (Axial Force) 是指沿着物体的纵轴施加的力。对于一根杆或柱子&#xff0c;轴向力可以是拉力或压力&#xff0c;具体取决于力的方向。 拉力 (Tensile Force)&#xff1a;使物体拉长的力。 压力 (Compressive…
阅读更多...
程序员学长 | 快速学习一个算法，GAN

程序员学长 | 快速学习一个算法，GAN

本文来源公众号“程序员学长”&#xff0c;仅用于学术分享&#xff0c;侵权删&#xff0c;干货满满。 原文链接&#xff1a;快速学习一个算法&#xff0c;GAN GAN 如何工作&#xff1f; GAN 由两个部分组成&#xff1a;生成器&#xff08;Generator&#xff09;和判别器&…
阅读更多...
C标准库读写文件

C标准库读写文件

函数介绍 库变量 变量描述size_t无符号整数类型&#xff0c;是sizeof关键字的结果&#xff0c;表示对象大小FILE文件流类型&#xff0c;适合存储文件流信息的对象类型 库宏 宏描述NULL空指针常量EOF表示已经到达文件结束的负整数stderr、stdin、stdout指向FILE类型的指针&a…
阅读更多...
行为树（BehaviorTree ）常见的几种节点类型

行为树（BehaviorTree ）常见的几种节点类型

阅读更多...
【AIGC】二、mac本地采用GPU启动keras运算

【AIGC】二、mac本地采用GPU启动keras运算

mac本地采用GPU启动keras运算 一、问题背景二、技术背景三、实验验证本机配置安装PlaidML安装plaidml-keras配置默认显卡 运行采用 CPU运算的代码step1 先导入keras包&#xff0c;导入数据cifar10&#xff0c;这里可能涉及外网下载&#xff0c;有问题可以参考[keras使用基础问题…
阅读更多...
starccm+软件许可优化解决方案

starccm+软件许可优化解决方案

starccm软件介绍 Simcenter Star CCM专注于CFD的多物理场仿真&#xff0c;支持流体动力学模拟、电池模拟、协同仿真、设计探索、电机、电化学、引擎模拟、移动物体、流变学、固体力学等多个方面&#xff0c;无论是真实的多物理场仿真&#xff0c;捕捉产品的完整几何形状&#x…
阅读更多...
LVS实验

LVS实验

LVS实验 nginx1 RS1 192.168.11.137 nginx2 RS2 192.168.11.138 test4 调度器 ens33 192.168.11.135 ens36 12.0.0.1 test2 客户端 12.0.0.10 一、test4 配置两张网卡地址信息 [roottest4 network-scripts]# cat ifcfg-ens33 TYPEEthernet BOOTPROTOstatic DEFROUTEyes DEVIC…
阅读更多...
利用 Plotly.js 创建交互式条形图

利用 Plotly.js 创建交互式条形图

本文由ScriptEcho平台提供技术支持 项目地址&#xff1a;传送门 利用 Plotly.js 创建交互式条形图 应用场景介绍 交互式条形图广泛应用于数据可视化和分析领域。它可以直观地展示不同类别或分组之间的数值差异&#xff0c;并允许用户通过交互操作探索数据。 代码基本功能介…
阅读更多...
【经典面试题】环形链表

【经典面试题】环形链表

1.环形链表oj 2. oj解法 利用快慢指针&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/typedef struct ListNode ListNode; bool hasCycle(struct ListNode *head) {ListNode* slow head, *fast…
阅读更多...
51单片机(STC8051U34K64)_RA8889_SPI4参考代码（v1.3)

51单片机(STC8051U34K64)_RA8889_SPI4参考代码（v1.3)

硬件&#xff1a;STC8051U34K64 RA8889开发板&#xff08;硬件跳线变更为SPI-4模式&#xff0c;PS101&#xff0c;R143&#xff0c;R141短接&#xff0c;R142不接&#xff09; STC8051U34K64是STC最新推出来的单片机&#xff0c;主要用于替换传统的8051单片机&#xff0c;与标…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023