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

最新推荐文章于 2024-07-11 23:28:27 发布
最新推荐文章于 2024-07-11 23:28:27 发布
阅读量655 收藏 11
点赞数 19
分类专栏： Cpp 文章标签： C++ STL list c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79465388/article/details/140360556
版权

标题：[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;
	};

}

完~

未经作者同意禁止转载

水墨不写bug
关注
  • 19
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
C++模拟实现list
03-11
C++模拟实现list
C++ 模拟实现list(迭代器)实现代码
08-30
C++ 模拟实现 List（迭代器）实现代码 C++ 模拟实现 List（迭代器）是指使用 C++ 语言来模拟实现 List 数据结构，并提供迭代器来遍历 List 中的元素。在本文中，我们将介绍如何使用 C++ 语言来模拟实现 List（迭代...
全国计算机等级考试模拟软件 二级C++
03-26
这款“全国计算机等级考试模拟软件 二级C++”是为了帮助考生更好地准备此类考试而设计的。 软件特点： 1. **全真模拟**：该软件提供了与实际考试相似的环境，让考生熟悉考试流程，了解题型和时间安排，增强应试能力...
用C++实现python的list风格
12-30
这是完整原代码，python中list是一种很有用的数据结构，而且使用非常方便。list本身是一种序列，是一块可存放多个值的连续内存...只是在C++中模拟python的操作，且只有list的操作。 对于学习运算符重载的方法非常有用。
Java数据结构-链表与LinkedList
daweidi的博客
07-11 688
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。LinkedList实现了List接口。LinkedList没有实现RandomAccess接口，因此不支持随机访问。LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O（1）方法解释尾插 e将 e 插入到 index 位置尾插 c 中的元素删除 index 位置元素。
Java链表LinkedList经典题目
lllsure的博客
07-11 480
既然用不了，那我们就借着这个思路改一下，给短的链表补上不就行了，换句话说，链表从后往前对齐，长链表前面多的那部分不可以有结点，直接跳过即可，这样问题就解决了。定义三个ListNode变量指向三个节点，cur指向的是当前要改变next的节点，pr指向的是cur.next要指向的节点，p是记录的作用，如果cur的next变成指向前面了，那么本来cur后面一个节点就丢失了，无法完成反转。应用的也是快慢指针的思想，这个就像在操场上跑步一样，如果一快一慢，而且还是闭环的话，那么两个人一定会相遇。
list的模拟实现
Liufan____的博客
07-11 332
首先，C++中用struct定义是可不加struct，重点是这里用了一个类模板，类模板的类名不是真正的类型且类模板不支持自动推类型，即_list_node不是真正的类型，定义变量时，_list_node<T>这种才是真正的类型，也就是用类模板定义变量时必须指定对应的类型。注：结构体模板或类模板在定义时可不加<T>,但使用时必须加<T>。
Redis数据结构详解：String、List、Set、Hash和Sorted Set
Cao_shuqi的博客
07-09 895
String 是 Redis 最基本的数据类型，一个键对应一个值，值可以是字符串、整数或浮点数。String 类型是二进制安全的，意味着可以存储任何类型的数据，如文本、图片序列化后的数据等。List 是一个有序的字符串链表，允许在链表的两端推入和弹出元素。它支持从左侧（头部）和右侧（尾部）进行插入和删除操作。List 可以用于实现诸如消息队列等功能。Set 是一个无序集合，包含唯一的字符串元素。Set 的主要功能是去重，它适合用于需要去重的场景，如统计唯一访客。Hash 是一个键值对集合，适合用于存储对象。
Java中的LinkedList（链表）（如果想知道Java中有关LinkedList的知识点，那么只看这一篇就足够了！）
秋刀鱼不做梦的编程日常
07-11 1207
Java中的LinkedList（链表）（如果想知道Java中有关LinkedList的知识点，那么只看这一篇就足够了！）
LRU Cache 双向链表以及STL list实现----面试常考
qq_40872103的博客
07-05 345
主要用了迭代器，对于初学者可能难以理解。可以看我的下一篇博客，详细阐述了迭代器设计思想！手写双向链表版本比较简单，在纸上画一画就能想通！
移动端Vant-list的二次封装，查询参数重置
weixin_45886797的博客
07-08 340
场景：在写项目需求的时候，移动端有用到vant-list组件。后续需求更新说要对列表数据页加搜索和筛选的功能。发现每次筛选完得在页面内手动重置一次查询参数。不方便，所以封了一层。
std::deque和std::list的区别是什么
2402_85246552的博客
07-07 385
std::deque（双端队列）和std::list（双向链表）是C++标准模板库（STL）中两种不同的序列容器，它们在内部实现、性能特性和使用场景上存在一些关键区别。
Linux内核 -- 内存管理之scatterlist结构使用
sz66cm 学习随笔
07-09 443
结构在 Linux 内核中主要用于 DMA（直接内存访问）操作中的内存管理。它允许将不连续的物理内存片段表示为一个逻辑上的连续块，从而使 DMA 操作可以高效地处理这些不连续的内存片段。
[leetcode]partition-list 分隔链表
xiaocong1990的博客
07-10 199
【代码】[leetcode]partition-list 分隔链表。
Java 中的集合框架有哪些主要接口？ArrayList 和 LinkedList 在使用场景上的不同是什么？
最新发布
liangzai215的专栏
07-11 344
List（列表）：这是一个有序集合，允许重复元素，且元素的插入顺序得到保持。你可以通过索引来访问列表中的元素。List接口的主要实现包括ArrayListLinkedList, 和Vector。Set（集）：这是不包含重复元素的集合。元素的插入顺序不被保证，除非使用的是像这样的具体实现，它在保持无重复的同时还维护了插入顺序。HashSet和TreeSet是Set接口的两个常见实现。Map（映射）：不同于上述两种接口，Map不是用来存储单一元素的，而是存储键值对（key-value pairs）。
JavaDS —— 单链表 与 LinkedList
hong_z_c的博客
07-10 691
JavaDS 链表
6、Redis系统-数据结构-07-QuickList
qq_29434541的博客
07-07 769
在 Redis 中，快速列表通过结合双向链表和压缩列表的优点，实现了高效的存储和操作，适用于需要频繁插入、删除和查找的场景。填充因子越小，每个节点包含的元素越少，插入和删除操作的性能越高，但内存利用率可能会下降。压缩深度越大，压缩列表节点之间的数据压缩程度越高，内存利用率越高，但解压缩操作的开销可能会增加；压缩深度越小，压缩列表节点之间的数据压缩程度越低，解压缩操作的开销较小，但内存利用率可能会下降。查找元素时，通过遍历快速列表节点，查找包含目标元素的压缩列表，然后在压缩列表中查找目标元素。
Java中 普通for循环， 增强for循环( foreach) List中增删改查的注意事项
weixin_46689011的博客
07-07 676
for foreach
c++模拟实现vector
09-01
引用和提供了关于实现vector的两种方法。其中，引用展示了一个使用reserve和push_back方法的示例，而引用展示了一个使用new和memcpy函数的示例。这两种方法都是常见的实现vector的方式。 在第一种方法中，通过reserve函数可以预留足够的内存空间，然后使用push_back函数逐个将元素添加到vector中。这种方法的好处是可以避免不必要的内存重分配，提高了效率。 而第二种方法使用new操作符在堆上分配内存空间，并使用memcpy函数将已有的vector对象的数据复制到新的内存空间中。通过这种方式，可以实现深拷贝，即两个vector对象拥有独立的内存空间。这种方法的好处是可以在不修改原始vector对象的情况下创建一个新的vector对象。 除了以上两种方法，还可以使用其他方式实现vector类。例如，可以使用动态数组来实现vector的底层数据结构，然后通过成员函数实现vector的各种操作，如增加、删除、查找等。 总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况选择。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水墨不写bug

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值