STL模拟实现List+迭代器

最新推荐文章于 2023-04-13 23:49:34 发布
最新推荐文章于 2023-04-13 23:49:34 发布
阅读量709 收藏
点赞数
分类专栏： 数据结构 C++ 文章标签： 数据结构 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_iverson/article/details/78426773
版权

List的底层数据结构的实现就是双向循环链表，下面给出结点的封装，简易迭代器的封装，还有头指针的封装和相关功能的实现和测试的结果

1.结点的封装代码如下：

template<class T>
struct ListNode//定义结点的类
{
public:
	ListNode<T> *_pre;//后指针
	ListNode<T> *_next;//前指针
	T _data;//储存数据
public:
	ListNode(const T& data = T())//构造函数
		:_pre(0)
		, _next(0)
		, _data(data){}
};

2.给出简易迭代器的封装代码。其实迭代器就是一个可以指向结点的指针

template<class T,class Ref,class Src>//迭代器的类
class Iterator
{
public:
	ListNode<T>* _pCur;
public:
	Iterator()//构造函数
		: _pCur(0){}
	Iterator(ListNode<T>* pCur)//有参数的构造函数
		:_pCur(pCur){}
	Iterator(const Iterator<T,Ref,Src>& s)//拷贝构造函数
		:_pCur(s._pCur){}
	Ref& operator*()
	{
		return _pCur->_data;
	}
	Src* operator->()
	{
		return &(_pCur->_data);
	}
	Iterator < T, Ref, Src > operator++(int)//后置++
	{
		Iterator<T, Ref, Src> temp(*this);
		_pCur = _pCur->_next;
		return temp;
	}
	Iterator < T, Ref, Src > operator++()//前置++
	{
		_pCur = _pCur->_next;
		return *this;
	}
	Iterator < T, Ref, Src > operator--()//前置--
	{
		_pCur = _pCur->_pre;
		return *this;
	}
	Iterator < T, Ref, Src > operator--(int)//后置--
	{
		Iterator < T, Ref, Src > temp(*this)
		_pCur = _pCur->_pre;
		return temp;
	}
	bool operator!=(const Iterator < T, Ref, Src >& s)
	{
		return _pCur != s._pCur;
	}
	bool operator==(const Iterator < T, Ref, Src >& s)
	{
		return _pCur == s->_pPcur;
	}
	
};
因为迭代器其实就是指向结点的指针，既然是指针所以其对象就要有指针的相关功能，所以给出了上述的运算符重载函数

3.下面给出头指针的封装和具体的迭代器和结点的结合使用，还有相关的功能的实现

//可以直接在里面使用迭代器
template<class T>
class ListHead//封装头指针的类
{
public:
	ListNode<T> *_head;//定义头指针成员变量,指向结点的指针
	typedef Iterator<T, T&, T*> Iterator;//在这个类中定义迭代器
public:
	ListHead()//无参构造函数
		:_head(new ListNode<T>)//给头结点开辟空间
	{
		_head->_pre = _head;
		_head->_next = _head;
	}
	ListHead(const T*array, size_t size)//有参数的构造函数
		:_head(new ListNode<T>)//开辟头结点
	{
		_head->_next = _head;
		_head->_pre = _head;
		for (size_t i =0 ; i < size; i++)
		{
			PushBack(array[i]);
		}
	}
	/*List(const List& l);
	List& operator=(const List& l);*/
	~ListHead()
	{
		Clear();
		delete []_head;
		_head = NULL;
	}

	void PushBack(const T& data)
	{
		ListNode<T> *NewNode = new ListNode<T>(data);
		if (Empty())
		{
			_head->_next = NewNode;
			NewNode->_next = _head;
			NewNode->_pre = _head;
			_head->_pre = NewNode;
		}
		else
		{
			ListNode<T>* pLast = _head->_pre;//找到最后一个结点
			NewNode->_next = _head;
			NewNode->_pre = pLast;
			pLast->_next = NewNode;
			_head->_pre = NewNode;
		}
	}
	void PushFront(const T& data)
	{
		ListNode<T> *NewNode = new ListNode<T>(data);
		if (Empty())
		{
			_head->_next = NewNode;//头指针指向第一个结点
			NewNode->_next = _head;//第一个结点next指向头指针
			NewNode->_pre = _head;//第一个结点pre向头指针
			_head->_pre = NewNode;//头指针pre指向第一个结点
		}
		else
		{
			NewNode->_next = _head->_next;
			NewNode->_pre = _head;
			_head->_next->_pre = NewNode;
			_head->_next = NewNode;
		}
	}
	void PopFront()//头删除
	{
		if (!Empty())
		{
			ListNode<T> *p = _head->_next;//保存第一个结点
			_head->_next = p->_next;
			p->_next->_pre = _head;
			delet p;
		}
	}
	void PopBack()//尾删除
	{
		if (!Empty())
		{
			ListNode<T> *p = _head->_pre->_pre;//保存倒数第二个结点
			delete p->_next;//销毁最后一个结点
			p->_next = _head;
			_head->_pre = p;
		}
	}
	Iterator Begin()//返回第一个结点的地址
	{
		return  Iterator(_head->_next);
	}
	Iterator End()//返回最后一个结点的地址
	{
		return  Iterator(_head->_pre);
	}
	Iterator Insert(Iterator pos, const T& data)//指定位置插入,返回插入的结点
	{
		ListNode<T>* pNewNode = new ListNode<T>(data);
		pNewNode->_next = pos._pCur;
		pos._pCur->_pre->_next = pNewNode;
		pNewNode->_pre = pos._pCur->_pre;
		pos._pCur->_pre = pNewNode;
		return Iterator(pNewNode);
	}
	Iterator Erase(Iterator pos)//指定位置删除,返回删除的下一个结点
	{
		ListNode<T> *src = pos._pCur->_next;
		pos._pCur->_pre->_next = pos._pCur->_next;
		pos._pCur->_next->_pre = pos._pCur->_pre;
		delete pos._pCur;
		pos._pCur = NULL;
		return src;
	}
		bool Empty()const
		{
			return _head->_pre == _head;//只有一个头结点
		}
		size_t Size()const
		{
			ListNode<T> *dest = _head->_next;//标记第一个结点
			size_t count = 0;
			while (dest!= _head)
			{
				dest = dest->_next;
				count++;
			}
			return count;
		}
		T& Front()
		{
			return _head->_next->data;
		}
		const T& Front()const
		{
			return _head->_next->data;
		}
		T& Back()
		{
			return _head->_pre->data;
		}
		const T& Back()const
		{
			return _head->_pre->data;
		}
		void Clear()
		{
			Iterator it = Begin();//得到第一个结点的地址
			while (it != End())
			{
				it=Erase(it);
			}
			_head->_next = _head;
			_head->_pre = _head;
		}
	template<class Iterator, class T>
	Iterator Find(Iterator first, Iterator last, const T& data)
		{
			while (first != last)
			{
				if (*first == data)
					return first;

				++first;
			}
		}
};

下面是我的测试代码和结果，你可以根据自己的想法去测试

void TestList()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	ListHead<int> s(arr, sizeof(arr) / sizeof(*arr));

	s.PushBack(6);
	s.PushFront(0);
	ListHead<int>::Iterator it = s.Begin();
	while (it != s.End())
	{
		cout << *it << "->";
		++it;
	}
	cout << *it;
	cout << "->NULL" << endl;

	cout << "Size()="<<s.Size() << endl;

	ListHead<int>::Iterator s1 = s.Find(s.Begin(), s.End(), 2);
	cout <<"s1=" <<*s1 << endl;

	ListHead<int>::Iterator s2 = s.Insert(s.Begin(), 100);
	ListHead<int>::Iterator it1 = s.Begin();
	while (it1 != s.End())
	{
		cout << *it1 << "->";
		++it1;
	}
	cout << *it1;
	cout << "->NULL" << endl;
}

下面给出整个项目的完整代码，

template<class T>
struct ListNode//定义结点的类
{
public:
	ListNode<T> *_pre;//后指针
	ListNode<T> *_next;//前指针
	T _data;//储存数据
public:
	ListNode(const T& data = T())//构造函数
		:_pre(0)
		, _next(0)
		, _data(data){}
};
template<class T,class Ref,class Src>//迭代器的类
class Iterator
{
public:
	ListNode<T>* _pCur;
public:
	Iterator()//构造函数
		: _pCur(0){}
	Iterator(ListNode<T>* pCur)//有参数的构造函数
		:_pCur(pCur){}
	Iterator(const Iterator<T,Ref,Src>& s)//拷贝构造函数
		:_pCur(s._pCur){}
	Ref& operator*()
	{
		return _pCur->_data;
	}
	Src* operator->()
	{
		return &(_pCur->_data);
	}
	Iterator < T, Ref, Src > operator++(int)//后置++
	{
		Iterator<T, Ref, Src> temp(*this);
		_pCur = _pCur->_next;
		return temp;
	}
	Iterator < T, Ref, Src > operator++()//前置++
	{
		_pCur = _pCur->_next;
		return *this;
	}
	Iterator < T, Ref, Src > operator--()//前置--
	{
		_pCur = _pCur->_pre;
		return *this;
	}
	Iterator < T, Ref, Src > operator--(int)//后置--
	{
		Iterator < T, Ref, Src > temp(*this)
		_pCur = _pCur->_pre;
		return temp;
	}
	bool operator!=(const Iterator < T, Ref, Src >& s)
	{
		return _pCur != s._pCur;
	}
	bool operator==(const Iterator < T, Ref, Src >& s)
	{
		return _pCur == s->_pPcur;
	}
	
};
//可以直接在里面使用迭代器
template<class T>
class ListHead//封装头指针的类
{
public:
	ListNode<T> *_head;//定义头指针成员变量,指向结点的指针
	typedef Iterator<T, T&, T*> Iterator;//在这个类中定义迭代器
public:
	ListHead()//无参构造函数
		:_head(new ListNode<T>)//给头结点开辟空间
	{
		_head->_pre = _head;
		_head->_next = _head;
	}
	ListHead(const T*array, size_t size)//有参数的构造函数
		:_head(new ListNode<T>)//开辟头结点
	{
		_head->_next = _head;
		_head->_pre = _head;
		for (size_t i =0 ; i < size; i++)
		{
			PushBack(array[i]);
		}
	}
	/*List(const List& l);
	List& operator=(const List& l);*/
	~ListHead()
	{
		Clear();
		delete []_head;
		_head = NULL;
	}

	void PushBack(const T& data)
	{
		ListNode<T> *NewNode = new ListNode<T>(data);
		if (Empty())
		{
			_head->_next = NewNode;
			NewNode->_next = _head;
			NewNode->_pre = _head;
			_head->_pre = NewNode;
		}
		else
		{
			ListNode<T>* pLast = _head->_pre;//找到最后一个结点
			NewNode->_next = _head;
			NewNode->_pre = pLast;
			pLast->_next = NewNode;
			_head->_pre = NewNode;
		}
	}
	void PushFront(const T& data)
	{
		ListNode<T> *NewNode = new ListNode<T>(data);
		if (Empty())
		{
			_head->_next = NewNode;//头指针指向第一个结点
			NewNode->_next = _head;//第一个结点next指向头指针
			NewNode->_pre = _head;//第一个结点pre向头指针
			_head->_pre = NewNode;//头指针pre指向第一个结点
		}
		else
		{
			NewNode->_next = _head->_next;
			NewNode->_pre = _head;
			_head->_next->_pre = NewNode;
			_head->_next = NewNode;
		}
	}
	void PopFront()//头删除
	{
		if (!Empty())
		{
			ListNode<T> *p = _head->_next;//保存第一个结点
			_head->_next = p->_next;
			p->_next->_pre = _head;
			delet p;
		}
	}
	void PopBack()//尾删除
	{
		if (!Empty())
		{
			ListNode<T> *p = _head->_pre->_pre;//保存倒数第二个结点
			delete p->_next;//销毁最后一个结点
			p->_next = _head;
			_head->_pre = p;
		}
	}
	Iterator Begin()//返回第一个结点的地址
	{
		return  Iterator(_head->_next);
	}
	Iterator End()//返回最后一个结点的地址
	{
		return  Iterator(_head->_pre);
	}
	Iterator Insert(Iterator pos, const T& data)//指定位置插入,返回插入的结点
	{
		ListNode<T>* pNewNode = new ListNode<T>(data);
		pNewNode->_next = pos._pCur;
		pos._pCur->_pre->_next = pNewNode;
		pNewNode->_pre = pos._pCur->_pre;
		pos._pCur->_pre = pNewNode;
		return Iterator(pNewNode);
	}
	Iterator Erase(Iterator pos)//指定位置删除,返回删除的下一个结点
	{
		ListNode<T> *src = pos._pCur->_next;
		pos._pCur->_pre->_next = pos._pCur->_next;
		pos._pCur->_next->_pre = pos._pCur->_pre;
		delete pos._pCur;
		pos._pCur = NULL;
		return src;
	}
		bool Empty()const
		{
			return _head->_pre == _head;//只有一个头结点
		}
		size_t Size()const
		{
			ListNode<T> *dest = _head->_next;//标记第一个结点
			size_t count = 0;
			while (dest!= _head)
			{
				dest = dest->_next;
				count++;
			}
			return count;
		}
		T& Front()
		{
			return _head->_next->data;
		}
		const T& Front()const
		{
			return _head->_next->data;
		}
		T& Back()
		{
			return _head->_pre->data;
		}
		const T& Back()const
		{
			return _head->_pre->data;
		}
		void Clear()
		{
			Iterator it = Begin();//得到第一个结点的地址
			while (it != End())
			{
				it=Erase(it);
			}
			_head->_next = _head;
			_head->_pre = _head;
		}
	template<class Iterator, class T>
	Iterator Find(Iterator first, Iterator last, const T& data)
		{
			while (first != last)
			{
				if (*first == data)
					return first;

				++first;
			}
		}
};


void TestList()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	ListHead<int> s(arr, sizeof(arr) / sizeof(*arr));

	s.PushBack(6);
	s.PushFront(0);
	ListHead<int>::Iterator it = s.Begin();
	while (it != s.End())
	{
		cout << *it << "->";
		++it;
	}
	cout << *it;
	cout << "->NULL" << endl;

	cout << "Size()="<<s.Size() << endl;

	ListHead<int>::Iterator s1 = s.Find(s.Begin(), s.End(), 2);
	cout <<"s1=" <<*s1 << endl;

	ListHead<int>::Iterator s2 = s.Insert(s.Begin(), 100);
	ListHead<int>::Iterator it1 = s.Begin();
	while (it1 != s.End())
	{
		cout << *it1 << "->";
		++it1;
	}
	cout << *it1;
	cout << "->NULL" << endl;
}
只需要加上头文件和主函数就可以正常运行测试了。

IT_iverson
关注
专栏目录
C++ STL - list 模拟实现+解析迭代器
TPON的博客
10-12 1011
STL - list iterator const_iterator reverse_iterator 模拟实现
C++ STL - vector 模拟实现+解析迭代器
TPON的博客
10-12 1304
STL - vector
类模板模拟实现STL中List
xy的博客
03-24 542
构造函数： 　　list<int> c1(3); //建一个含三个默认值是0的元素的链表 　　list<int> c2(5,2); //建一个含五个元素的链表，值都是2 　　list<int> c4(c2); //建一个c2的拷贝构造链表 成员函数： （1）begin() 返回指向链表第一个元素的迭代器。 （2）end() 返回指向链表最后一个元素之后的迭代器。
模拟实现STL中list（用迭代器）
baidu_37964044的博客
03-14 348
在上一篇博客中有很详细的介绍迭代器的用法。点击打开链接STL中list底层其实是带头双向循环列表，STL中使用迭代器（iterator)指向list的结点，并进行增删查改等操作，本篇我们模拟STL中list的常用操作。先来构造list中的结点template&lt;class T&gt; struct My_ListNode { T _date; My_ListNode&lt;T&gt;* _...
STL学习——浅谈List类的模拟实现
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
06-20 241
       本文模拟实现了c++标准模板库中的List。 它的底层实现是一个带头结点的双向循环链表。        一个注意要点是，不同于vector和string的迭代器的封装 typedef T* Iterator List 采用了一个类来封装迭代器...
STL list迭代器
qq_33521663的博客
09-20 421
STL list中迭代器 1.链表的结构 链表的结构： 每一个链表上的节点都有三个部分：前指针，值，后指针 分别说明一下这三者的作用： 前指针(pre)：指向前一个节点的值 后指针(next)：指向后一个节点的值 值：节点上保存的东西 链表是线性结构，由此我们可以知道链表上的各个节点的连接方式就是通过前后指针相连接，要想查找到某个节点只有通过前面的节点或者后面的节点。 缺点：所以要查找链表中的某一个节点的值只有通过遍历的方式去查找！ 优点：插入删除某一个节点非常的方便 例如：现在又nod1，nod2，
C++ STL学习之【list的模拟实现】
最新发布
北 海的博客
04-13 4415
STL中的list是一个双向带头循环链表，作为链表的终极形态，各项操作性能都很优秀，尤其是list中迭代器的设计更是让人拍案叫绝，如此优秀的容器究竟是如何实现的？本文将带你共同揭晓
STL容器中list与迭代器iterator的模拟实现
L_XRUI的博客
12-30 2059
list在容器中结构是有一个头结点_head，头结点指向第一个结点，尾结点指向头结点，它为双向循环链表，在其中它有自己的迭代器可以类似于智能指针，用于数据的访问和算法的配合。 代码实现： #include #include #include #include using namespace std; template struct _ListNode //结点结构 { T
【C++ STL】list 容器（介绍、使用、@迭代器失效、@迭代器的分类与实现方式、模拟实现、list 和 vector 的对比）
codewinter的博客
05-25 1211
文章目录一、STL - list 的介绍二、list 的使用2.1 常见构造2.2 迭代器及其遍历操作2.3 容量操作2.4 访问操作2.5 修改操作① 迭代器失效（⭐）② 成员 / 非成员 swap 函数2.6 容器操作（了解，用的很少）三、容器迭代器（重要）3.1 容器迭代器的分类（⭐重要）3.2 迭代器的实现方式分析（⭐重要）四、stl_list 源码剖析4.1 list 的底层结构五、list 的模拟实现5.1 list 的节点结构5.2 list 的迭代器（⭐重要）① 迭代器的结构② 一些思考（⭐
STL:C ++ STL使用
03-06
- 迭代器是STL中的关键概念，它像指针一样，指向容器中的元素，支持各种操作如前向移动、读取和修改元素。 3. 预算器（Allocator）： - 内存管理工具，负责为容器分配和释放内存。默认的预算器是`std::allocator`...
C++中List 的用法
foodvc的专栏
12-18 2350
#include  #include  #include  #include  using namespace std; //创建一个list容器的实例LISTINT typedef list LISTINT; //创建一个list容器的实例LISTCHAR typedef list LISTCHAR; void main(void) {   //-----------------------
python 中list+=[1]与list =list+[1]
BGONE的博客
03-09 5752
python 中list+=[1]与list =list+[1]的区别
STL：模拟实现List(迭代器版本的List）
dangzhangjing97的博客
08-11 1083
一、什么是List？ List是STL标准库中的一个容器，相当于链表 二、List的优点？ 1.通用性（因为List的实现使用了模板）
STL------List与迭代器的实现
zhangye3017的博客
06-19 842
1. List 　　List是STL库（标准模板库）中的一个容器。它的实质上就是一个双向带头循环链表，这样的设计有以下几个优点： 　　 随机插入数据时，不用遍历链表，去找某一特定位置 尾插时，只需head-&amp;gt;prev就可找到，提高了效率 在链表中删除数据时，也只需给出迭代器的位置即可，不需遍历链表找 到其前一个，或者采用替换删除的方法删除节点 2...
【STL】迭代器与List的模拟实现
皓皓松的博客
12-22 2996
什么是List List是STL库（标准模板库）中的一个容器。它的实质上就是一个双向链表，而且要注意的是，这个双向链表是有头的； 这样的设计是STL中一个很巧妙的地方， 它解决了： （1）插入数据时的判断问题，不用判断链表中有没有数据 （2）实现end()函数的时候仅仅只用一个 _head->_prev就可以找到 迭代器 这里，我们还要介绍另一个概念，迭代器 所谓迭代器，就
STL库中的list的使用和模拟实现
pigff的博客
09-24 672
简单介绍list上文我们讲到了STL库中的vector的使用和模拟实现，其实list和vector在很多地方都有相似之处。STL库中的list是一个双向循环链表。它的简单的结构如图 我们还是先来看看它里面有什么。list的内容与使用一. 首先还是雷打不动的三个成员函数，构造函数，析构函数和赋值运算符重载。二. 其次是迭代器。这里需要注意一下的是，begin（）返回的是第一个元素的位置，
[C++ STL] 迭代器（iterator）详解
weixin_30343157的博客
01-12 365
背景：指针可以用来遍历存储空间连续的数据结构，但是对于存储空间非连续的，就需要寻找一个行为类似指针的类，来对非数组的数据结构进行遍历。因此，我们引入迭代器概念。 一、迭代器（iterator）介绍 迭代器（Iterator）是一种检查容器内元素并遍历元素的数据类型。迭代器是指针的泛化，它允许程序员用相同的方式处理不同的数据结构（容器）。 迭代器的功能 共有五种迭代器，各个迭代器的功能...
模拟实现STL中的List容器
wxx2222222的博客
03-23 377
List.h#include <iostream> #include <assert.h> using namespace std;//结点结构 template<class T> struct ListNode { ListNode(const T&data = T()) :_prev(0) ,_next(0) ,_data(data)
C++标准模板库STL详解：容器、迭代器与算法
3. 算法：STL提供了大量预定义的算法函数模板，如sort、find、copy等，这些算法可以应用于任何支持迭代器的容器，实现了对数据集合的各种操作。 4. 函数对象：也称为仿函数，它们是重载了`operator()`的类对象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值