STL模拟实现List+迭代器

最新推荐文章于 2019-07-18 16:53:40 发布
最新推荐文章于 2019-07-18 16:53:40 发布
阅读量652 收藏
点赞数
分类专栏： 数据结构 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
iter:Go实现C ++ STL迭代器和算法
03-08
重复去实现C ++ STL迭代器和算法。 更少的手写循环，更具表现力的代码。 README翻译：动机尽管Go没有泛型，但我们值得拥有可重用的通用算法。 iter可通过多种方式帮助改进Go代码： 一些简单的循环不太可能是错误的或...
C++ STL学习之【list的模拟实现】
北 海的博客
04-13 4281
STL中的list是一个双向带头循环链表，作为链表的终极形态，各项操作性能都很优秀，尤其是list中迭代器的设计更是让人拍案叫绝，如此优秀的容器究竟是如何实现的？本文将带你共同揭晓
C++中List 的用法
foodvc的专栏
12-18 2308
#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 5684
python 中list+=[1]与list =list+[1]的区别
【STL】迭代器与List的模拟实现
皓皓松的博客
12-22 2957
什么是List List是STL库（标准模板库）中的一个容器。它的实质上就是一个双向链表，而且要注意的是，这个双向链表是有头的； 这样的设计是STL中一个很巧妙的地方， 它解决了： （1）插入数据时的判断问题，不用判断链表中有没有数据 （2）实现end()函数的时候仅仅只用一个 _head->_prev就可以找到 迭代器 这里，我们还要介绍另一个概念，迭代器 所谓迭代器，就
STL：模拟实现List(迭代器版本的List）
dangzhangjing97的博客
08-11 1055
一、什么是List？ List是STL标准库中的一个容器，相当于链表 二、List的优点？ 1.通用性（因为List的实现使用了模板）
STL简单迭代器的实现
05-10
介绍博客：http://blog.csdn.net/chengonghao/article/details/51360792
浅谈c++ stl迭代器失效的问题
08-31
下面小编就为大家带来一篇浅谈c++ stl迭代器失效的问题。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧，祝大家游戏愉快哦
Stl的list容器迭代器的用法1
08-08
和array、vector、deque 容器的迭代器相比，list 容器迭代器最大的不同在于，其配备的迭代器类型为双向迭代器，而不再是随机访问迭代器。值得一提的
STL------List与迭代器的实现
zhangye3017的博客
06-19 813
1. List 　　List是STL库（标准模板库）中的一个容器。它的实质上就是一个双向带头循环链表，这样的设计有以下几个优点： 　　 随机插入数据时，不用遍历链表，去找某一特定位置 尾插时，只需head-&amp;gt;prev就可找到，提高了效率 在链表中删除数据时，也只需给出迭代器的位置即可，不需遍历链表找 到其前一个，或者采用替换删除的方法删除节点 2...
C++/C++11中头文件iterator的使用
网络资源是无限的
09-14 1万+
<iterator>是C++标准程序库中的一个头文件，定义了C++ STL标准中的一些迭代器模板类，这些类都是以std::iterator为基类派生出来的。迭代器提供对集合(容器)元素的操作能力。迭代器提供的基本操作就是访问和遍历。迭代器模拟了C++中的指针，可以有++运算，用*(解引用算符，deference)或->算符来访问容器中的元素。容器中元素如果改变了所用内存，也不影响...
STL学习——浅谈List类的模拟实现
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
06-20 223
       本文模拟实现了c++标准模板库中的List。 它的底层实现是一个带头结点的双向循环链表。        一个注意要点是，不同于vector和string的迭代器的封装 typedef T* Iterator List 采用了一个类来封装迭代器...
STL list迭代器实现
c++
07-18 1031
list list是一个线性双向链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指针将有序的元素链接起来。由于其结构的原因，list 随机检索的性能非常的不好，因为它不像vector 那样直接找到元素的地址，而是要从头一个一个的顺序查找，这样目标元素越靠...
模拟实现STL中list（用迭代器）
baidu_37964044的博客
03-14 308
在上一篇博客中有很详细的介绍迭代器的用法。点击打开链接STL中list底层其实是带头双向循环列表，STL中使用迭代器（iterator)指向list的结点，并进行增删查改等操作，本篇我们模拟STL中list的常用操作。先来构造list中的结点template&lt;class T&gt; struct My_ListNode { T _date; My_ListNode&lt;T&gt;* _...
vector&list
sinat_39527002的博客
10-16 254
一、vector&list的使用和区别 STL(标准模板库)是一个C++的软件库，也是C++标准程序库的一部分。vector和list相当于容器，这些容器应该都是STL里面的一个类。而vector封装数组，list封装链表。 vector #include vectora(10);     //类型为int,数量为10 a[1] = {1};     //第二个元素赋值为1 cout
[C++ STL] 迭代器（iterator）详解
weixin_30343157的博客
01-12 350
背景：指针可以用来遍历存储空间连续的数据结构，但是对于存储空间非连续的，就需要寻找一个行为类似指针的类，来对非数组的数据结构进行遍历。因此，我们引入迭代器概念。 一、迭代器（iterator）介绍 迭代器（Iterator）是一种检查容器内元素并遍历元素的数据类型。迭代器是指针的泛化，它允许程序员用相同的方式处理不同的数据结构（容器）。 迭代器的功能 共有五种迭代器，各个迭代器的功能...
模拟实现STL中的List容器
wxx2222222的博客
03-23 344
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 list遍历器使用方法
热门推荐
FrankDura的博客
01-06 2万+
以int类型的list为例：使用迭代器输出：list<int> con; //声明一个list list<int>::iterator it; //声明一个迭代器 for(it = con.begin();it!=con.end();it++){ cout << *it <<endl; }使用迭代器删除指定值：list<int> con; //声明一个li
C++中，STL list容器的迭代器实现
最新发布
05-04
STL中的list容器是一个双向链表，因此它的迭代器也是一个双向迭代器。 list迭代器的定义如下： ```c++ template class list { public: // ... class iterator { public: typedef T value_type; typedef T& ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值