9.【CPP】List （迭代器的模拟实现||list迭代器失效||list的模拟实现）

最新推荐文章于 2024-07-09 21:26:33 发布
最新推荐文章于 2024-07-09 21:26:33 发布
阅读量901 收藏 15
点赞数 20
分类专栏： CPP 文章标签： list 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73865858/article/details/135990310
版权

介绍

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

list迭代器的实现

普通迭代器

template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _prev;
		list_node<T>* _next;

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

	template<class T>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T> iterator;

		node* _node;

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

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

		iterator& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		iterator operator++(int)
		{
			iterator tmp(*this);
			_node = _node->_next;
			return tmp;
		}
		
		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		iterator operator--(int)
		{
			iterator tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
		bool operator!=(const iterator& it )const
		{
			return _node != it._node;
		}

		bool operator==(const iterator& it)const
		{
			return _node == it._node;
		}
	};

const迭代器

看下面这段代码能否编译通过
在这里插入图片描述
如果传一个const对象，那么就需要实现对应的const迭代器，否则会出现权限的放大，是会报错的。
在这里插入图片描述
如果声明成这样呢？

typedef const iterator const_iterator

这是错误的。这就相当于iterator本身是const，那么就不能执行++操作，迭代器不能动还叫啥迭代器。所以我们处理的方法是返回一个const迭代器，重新实现一个const_iterator类。基本都复用普通迭代器的代码，就解引用时返回const T&。

template<class T>
	struct __list_const_iterator
	{
		typedef list_node<T> node;
		typedef __list_const_iterator<T> const_iterator;

		node* _node;

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

		const T& operator*()
		{
			return _node->_data;
		}

		const_iterator& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		const_iterator operator++(int)
		{
			const_iterator tmp(*this);
			_node = _node->_next;
			return tmp;
		}

		const_iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		const_iterator operator--(int)
		{
			const_iterator tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
		bool operator!=(const const_iterator& it)const
		{
			return _node != it._node;
		}

		bool operator==(const const_iterator& it)const
		{
			return _node == it._node;
		}
	};

这样我们代码就不报错，顺利打印出了数据

在这里插入图片描述

成员函数屁股后的const

	const iterator begin()const//后面的const修饰的是this指针指向的内容（*this），即_head本身不能被改变，指向对象的内容可变
		{
			return const iterator(_head->_next);
		}

改进代码

const迭代器还要去实现一个几乎相同的类，就改了个名字叫const_iterator，除了解引用返回T的引用时不同（const T&），那么我们在实现iterator迭代器类的时候加一个模版参数Ref表示引用，typedef不同的迭代器实例化不同的Ref即可解决。
在这里插入图片描述
在这里插入图片描述
不得不说想出这种写法的人真的是个天才

list反向迭代器位置

在这里插入图片描述

list迭代器失效

前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的**，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响**

list模拟实现代码

注意反向迭代器的实现是复用了正向迭代器

#include<iostream>
#include<cassert>

namespace pqd
{
	template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _prev;
		list_node<T>* _next;

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

	template<class T,class Ref,class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T,Ref,Ptr> iterator;

		node* _node;

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

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

		Ptr operator->()
		{
			return &_node->_data;
		}

		iterator& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		iterator operator++(int)
		{
			iterator tmp(*this);
			_node = _node->_next;
			return tmp;
		}
		
		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		iterator operator--(int)
		{
			iterator tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
		bool operator!=(const iterator& it )const
		{
			return _node != it._node;
		}

		bool operator==(const iterator& it)const
		{
			return _node == it._node;
		}
	};

	template<class Iterator,class Ref,class Ptr>
	struct ReverseIterator
	{
		typedef ReverseIterator<Iterator,Ref,Ptr> Self;
		Iterator _cur;

		ReverseIterator(Iterator it)
			:_cur(it){}

		Self& operator++()
		{
			--_cur;
			return *this;
		}

		Self& operator++(int)
		{
			Iterator tmp(_cur);
			--_cur;
			return tmp;
		}

		Self& operator--()
		{
			++_cur;
			return *this;
		}

		Self& operator--(int)
		{
			Iterator tmp(_cur);
			++_cur;
			return tmp;
		}

		 Ref operator*()
		{
			Iterator tmp = _cur;
			--tmp;
			return *tmp;
		}

		bool operator!=(const Self& s)
		{
			return _cur != s._cur;
		}
	};

	template<class T>
	class list
	{
	public:
		typedef __list_iterator<T,T&,T*> iterator;
		typedef __list_iterator<T,const T&,const T*> const_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<iterator, const T&, const T*> const_reverse_iterator;

		typedef list_node<T> node;

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

		list()
		{
			empty_init();
		}

		template<class Iterator>
		list(Iterator first, Iterator last)
		{
			empty_init();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		//lt2(lt1)
		/*list(const list<T>& lt)
		{
			empty_init();
			for (auto e : lt)
			{
				push_back(e);
			}
		}*/
		//现代写法
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
		}

		list(const list<T>& lt)
		{
			empty_init();

			list<T> tmp(lt.begin(), lt.end());
			swap(tmp);
		}

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


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

		const_iterator begin()const//后面的const修饰的是this指针指向的内容（*this），即_head本身不能被改变，指向对象的内容可变
		{
			return const_iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		const_iterator end()const
		{
			return const_iterator(_head);
		}

		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}


		void push_back(const T& val)
		{
			node* tail = _head->_prev;
			node* newnode = new node(val);
			tail->_next = newnode;
			newnode->_prev = tail;
			newnode->_next = _head;
			_head->_prev = newnode;
		}

		void insert(iterator pos, const T& x)
		{
			node* cur = pos._node;
			node* prev = cur->_prev;
			node* newnode = new node(x);

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

		iterator erase(iterator 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);
		}

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

		void clear()//不清理头节点
		{
			iterator it = begin();
			while (it != end())
			{
				it=erase(it);//或者erase(it++);返回的是it++前的拷贝
				it++;
			}
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
	private:
		node* _head;
	};

	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, 2));
		lt.push_back(AA(1, 3));
		lt.push_back(AA(1, 4));

		list<AA>::iterator it = lt.begin();
		while (it != lt.end())
		{
			std::cout << it->_a1 << ":" << it->_a2 << std::endl;
			it++;
		}
		lt.clear();
	}


	void print_list(const list<int>& lt)
	{
		list<int>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			std:: cout << *it << " ";
			++it;
		}

	}

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

	}

	void test_list3()
	{
		list<int> lt1;
		lt1.push_back(1);
		lt1.push_back(2);
		lt1.push_back(3);
		list<int> lt2(lt1);
		for (auto e : lt2)
		{
			std::cout << e << std::endl;
		}
	}

	void test_list4()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(5);

		auto rit =lt.rbegin();
		while (rit != lt.rend())
		{
			std::cout << *rit << " ";
			++rit;
		}
	}
}
MLGDOU
关注
  • 20
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于list循环删除元素,迭代器失效的问题详解
08-31
在编程中，特别是涉及到容器（如C++中的`std::list`）的迭代操作时，一个常见的问题是迭代器失效。本文将深入探讨这个问题，并提供一个关于如何在删除元素时避免迭代器失效的示例。 首先，我们需要理解迭代器是什么...
vector list map 遍历删除制定元素 防止迭代器失效的实例
12-25
// k_control.cpp : 定义控制台应用程序的入口点。 // #include “stdafx.h” #include “stdio.h” #include #include #include #include <list> using namespace std; int _tmain(int argc, _TCHAR* argv[]) { ...
List和list迭代器的模拟实现
wutongguo的博客
03-27 597
主要是list 的模拟实现和迭代器的底层
【C++】list的模拟实现@STL —— 迭代器
浮光掠影
04-03 2992
我们的开始，是很长的电影，放映了三年，我票都还留着。
[C++](12)list的使用与模拟实现：list迭代器实现
CegghnnoR的博客
07-13 1015
了解 list 的使用。list 的实现，关于迭代器的实现是本章的重点，有助于深入对类和对象，模板的理解
STL的list(二)：模拟实现 && 迭代器模板
m0_73975164的博客
04-06 881
const_iterator而不是const iterator，前者是别名，后者表示迭代器本身不能修改，const迭代器要的是迭代器指向的对象不能被修改而不是迭代器本身不能被修改
关于STL的erase()陷阱-迭代器失效问题的总结
08-31
然而，使用`erase()`时需要特别注意的一个问题是迭代器失效，即在删除元素后，与该元素相关的迭代器将不再有效。本文将深入探讨这个问题，并通过实例分析在不同类型的STL容器中如何安全地使用`erase()`。 首先，让...
vector, list, map在遍历时删除符合条件的元素实现方法
08-31
在删除元素时，如果使用迭代器，需要注意的是，删除操作会使得迭代器失效。因此，当删除一个元素后，不能直接递增原来的迭代器，而应该使用`erase()`函数返回的新迭代器。以下是在`vector`中删除元素的示例： ```...
鸿蒙语言基础类库：【@ohos.util.ArrayList (线性容器ArrayList)】
2301_76813281的博客
07-09 382
本模块首批接口从API version 8开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。点击或者复制转到。ArrayList是一种线性数据结构，底层基于数组实现。ArrayList会根据实际需要动态调整容量，每次扩容增加50%。ArrayList和[Vector]相似，都是基于数组实现。它们都可以动态调整容量，但Vector每次扩容增加1倍。ArrayList和[LinkedList]相比，ArrayList的随机访问效率更高。
SwiftUI中List的liststyle样式及使用详解添加、移动、删除、自定义滑动
07-04 1205
SwiftUI的swipeActions()修饰符允许你添加一个或多个滑动动作按钮到你的列表行，可选地控制他们属于哪一边，以及他们是否应该被触发使用一个完整的滑动。先看下代码及效果图：swipeActions()方法有三个参数，第一个edge决定操作按钮放哪边；第二个allowsFullSwipe决定完全滑动是否自动执行第一个操作，默认值为true；第三个即是内容闭包了。关于样式，只能通过tint设置背景色，如果不设置，系统默认是灰色的。
vector与list的简单介绍
2301_81265915的博客
07-04 967
vector是表示大小可以变化的数组的序列容器。就像数组一样，vector对其元素使用连续的存储位置，这意味着也可以使用指向其元素的常规指针上的偏移量来访问其元素，并且与数组中的元素一样高效。但与数组不同的是，它们的大小可以动态变化，它们的存储由容器自动处理。在内部，vector使用动态分配的数组来存储其元素。当插入新元素时，可能需要重新分配此数组才能增大大小，这意味着分配一个新数组并将所有元素移动到该数组。
LRU Cache 双向链表以及STL list实现----面试常考
qq_40872103的博客
07-05 293
主要用了迭代器，对于初学者可能难以理解。可以看我的下一篇博客，详细阐述了迭代器设计思想！手写双向链表版本比较简单，在纸上画一画就能想通！
移动端Vant-list的二次封装，查询参数重置
weixin_45886797的博客
07-08 225
场景：在写项目需求的时候，移动端有用到vant-list组件。后续需求更新说要对列表数据页加搜索和筛选的功能。发现每次筛选完得在页面内手动重置一次查询参数。不方便，所以封了一层。
C++之List模拟实现
qq_55958734的博客
07-09 563
一文带你掌握list模拟实现
ListView
qq_63589255的博客
07-08 427
降低findViewById的使用，提高运行速度。5、使用ViewHolder优化适配器。
关于string的‘\0‘与string，vector构造特点加部分特别知识点的讨论
2301_81265915的博客
07-06 951
你真的了解string的'\0'么？你知道创建一个string a("abcddddddddddddddddddddddddd", 16);这样的string对象要创建多少个对象么？你知道string与vector进行扩容时进行了怎么的操作么？你知道怎么求Vector 最大 最小值 索引 位置么？
Linux内核 -- 内存管理之scatterlist结构使用
最新发布
sz66cm 学习随笔
07-09 253
结构在 Linux 内核中主要用于 DMA（直接内存访问）操作中的内存管理。它允许将不连续的物理内存片段表示为一个逻辑上的连续块，从而使 DMA 操作可以高效地处理这些不连续的内存片段。
Android EditText+ListPopupWindow实现可编辑的下拉列表
D_AKJS
07-09 472
2.生成下拉数据（这里的数据可换成真实的数据库数据），监听文本变化。属性，EditText可以添加上下左右图片资源，我们添加右边即可。里面的图片可直接再阿里巴巴图标库搜索"上拉"、"下拉"即可。下箭头item_icon_down.xml。方法的参数分别是设置左、上、右、下位置。上箭头item_icon_up.xml。
vector迭代器失效
07-29
在使用vector时，迭代器失效是一个常见的问题。迭代器失效指的是迭代器所指向的元素在操作后发生了改变，导致迭代器无法继续使用。在你提供的引用中，迭代器失效的原因是在使用erase函数删除元素后，迭代器指向的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值