自定义双向列表容器（含迭代器）

最新推荐文章于 2024-10-09 16:09:40 发布

风云来

最新推荐文章于 2024-10-09 16:09:40 发布

阅读量1.2k

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/chenjiayi_yun/article/details/8806852

c++ 专栏收录该内容

102 篇文章

订阅专栏

本文介绍了一种双向链表及其迭代器的实现方法。通过重载操作符对节点进行封装，实现了列表中元素的前后遍历。代码示例展示了如何构建双向链表，并通过迭代器进行元素插入和遍历。

实现双向列表迭代器的实现是重载一些常用的操作符来对node进行一个封装。

实际的数据是存储在node的链表里面。

#include<iostream>
using namespace std;

//////////////////////////////////////////////////////////////////////////
/////列表中的实际数据节点
//////////////////////////////////////////////////////////////////////////
template<class T>
class node
{
public:
	node(){}
	node(T t){data = t;}
	T data;
	node<T> *pre;
	node<T> *next;
};

//////////////////////////////////////////////////////////////////////////
/////迭代器是对节点的类封装，增加了操作符的使用,并提供对外接口的类型
//////////////////////////////////////////////////////////////////////////
template<class T>
class iter
{
public:
typedef node<T> * lnode;
	lnode pnode;
	iter(const T & a):pnode(a.pnode){}
	iter(){}
	iter(const lnode & a):pnode(a){}

	inline T & operator *() const {return (pnode->data);}
	inline T * operator ->()const {return &(operator *());}
	inline bool operator !=(iter<T> & a)const {return pnode != a.pnode;}
	inline bool operator ==(iter<T> & a)const {return pnode == a.pnode;}
	inline iter<T> & operator++() {pnode = pnode->next; return *this;}//++ 前缀,operator++();  返回*this才使用返回引用
	inline iter<T> & operator--() {pnode = pnode->pre; return *this;}//-- 前缀,operator--();
	inline iter<T> operator--(int) {iter<T> tmp=*this; pnode = pnode->pre;return tmp;}// -- 后缀，实际是调用operator--(0)
	inline iter<T> operator++(int) {iter<T> tmp=*this; pnode = pnode->next;return tmp;}// ++ 后缀，实际是调用operator++(0)
};

template<class T>
class mylist
{
public:
typedef iter<T> iterator;//容器迭代器使用一个模板实现
typedef node<T> * np;
	mylist(T a);
	mylist();
	~mylist();
	iterator first();
	iterator end();
	void insert(T d);
	void clear();
private:
	np m_end;
	np m_first;
};

template<class T>
mylist<T>::mylist(T a)
{
	insert(a);
}

template<class T>
mylist<T>::mylist()
{
	m_end= new node<T>;
	m_end->pre = m_end;
	m_end->next = m_end;
	m_first = m_end;
}

template<class T>
mylist<T>::~mylist()
{
	delete m_end;
}

template<class T>
void mylist<T>::clear()
{
	np tempNext=NULL;
	while(m_first != m_end)
	{
		tempNext = (np)m_first->next;
		delete m_first;//跟stl有点差异的实现，是为了这里的内存处理
		m_first = tempNext;
	}
}

template<class T>
void mylist<T>::insert(T d)// 新加的节点是在跟节点前面(new node)->next  m_ln（root）->pre (new node)
{
	node<T> *newNode=new node<T>;

	newNode->data = d;
	newNode->pre = m_end->pre;
	newNode->next = m_end;

	((np)m_end->pre)->next = newNode;
	m_end->pre = newNode;
	if (m_first == m_end)//设置第一个节点
	m_first = newNode;
}

template<class T>
typename mylist<T>::iterator mylist<T>::first()
{
	return m_first;
}

template<class T>
typename mylist<T>::iterator mylist<T>::end()
{
	return m_end;
}

int main()
{
	mylist<int> l;
	l.insert(99);
	l.insert(10);
	l.insert(93);
	l.insert(29);
	l.insert(59);
	l.insert(69);
	l.insert(79);
	l.insert(66);
	l.insert(340);
	l.insert(0);
	l.insert(330);
	
	mylist<int>::iterator firstNode,endNode;
	firstNode=l.first();
	firstNode++;
	firstNode--;
	endNode=l.end();
	
	while(firstNode != endNode)
	{
		cout<<*firstNode<<endl;
		++firstNode;
	}
	l.clear();
	system("pause");
	return 0;
}