模拟实现list类

一.list简介

listC++ STL中的一个容器,是一个双向链表,可以存储任意类型的元素。list中的元素可以通过指针在链表中进行高效的插入和删除操作,因此list通常被用于需要频繁进行插入和删除操作的场合。

二.实现list类的准备工作

1.定义list节点

为了区别于库中的list类,我们可以在自己的命名空间中定义list类。list的基本成员变量只有一个——list的头结点(head)并且头节点内不存储有效数据。

定义结点结构:

namespace dianxia
{
	//定义结点结构
	template<class T>
	struct ListNode
	{
		struct ListNode<T>* _next; // 指向下一个结点
		struct ListNode<T>* _prev; // 指向前一个结点
		T _data; // 结点存储的数据

		ListNode(const T& data = T()) // 构造函数 // 申请一个节点 
			:_next(nullptr),
			_prev(nullptr),
			_data(data)
		{}
	};
}

2.定义list迭代器

迭代器——作为list最精华的部分,有着及其重要的作用,且同样为list模拟实现中最难的一部分。通过本章的内容,我们对于迭代器的理解会更上一层楼!

stringvector的学习中,我们经常使用下标+[]来访问容器的元素,非常方便。但是到了list以后的内容,[]访问元素的方法将不再适用,我们将使用迭代器。

前面的文章中曾经简单的提到过迭代器,简单来说它是一种泛型指针却又不单纯是指针,接下来我们就模拟实现list的迭代器。

迭代器本质就是对指针的封装模拟指针的行为,所以我们需要通过运算符重载来模拟实现指针的++--以及*->等操作。

我们将迭代器可以实现的一系列操作封装成类:

	// 三个参数的含义分别为:
	//类型T
	//类型T的引用
	//类型T的指针
	template<class T,class Ref,class Ptr> 
	struct _list_iterator
	{
		typedef ListNode<T> Node;
		typedef _list_iterator<T, Ref, Ptr> self;
		
		Node* _node; //迭代器的基本成员变量

		_list_iterator(node* node)
			:_node(node)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
	
		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}
	
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
	
		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
	
		Ref& operator*()
		{
			return _node->_data;
		}
	
		Ptr& operator->()
		{
			return &(_node->_data);
		}
	
		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	
		bool operator!=(const self& s)
		{
			return _node != s._node;
		}
	}

三.模拟实现list类

有了list的节点和list的迭代器,下面我们就来是实现list类本身的成员函数:

1.定义list类

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		// 类型重命名——普通迭代器
		typedef _list_iterator<T,T&,T*> iterator; 
		// 类型重命名——const迭代器
		typedef _list_iterator<T, const T&,const T*> const_iterator; 
	
	private:
		Node _node; 
	}

2.构造函数&析构函数

	//构造函数
	list()
	{
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;
	}
	//析构函数
	~list()
	{
		clean();
		delete _head;
		_head = nullptr;
	}

3.迭代器相关函数

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

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

	const_iterator begin() const
	{
		return const_iterator(_head->_next);
	}

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

4.插入及删除相关操作

	//插入操作
	void insert(iterator pos,const T& data)
	{
		node* newNode = new Node(data);

		Node* cur = pos._node;
		Node* prev = cur->_prev;

		newNode->_prev = prev;
		prev->_next = newNode;
		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 push_back(const T& data)
	{
		insert(end(),data);
	}
	//尾删
	void pop_back()
	{
		erase(--end());
	}
	//头插
	void push_front(const T& data)
	{
		insert(begin(), data);
	}
	//头删
	void pop_front()
	{
		erase(begin());
	}
	//清空list
	void clean() 
	{
		iterator it = begin();
		while (it != end())
		{
			//it = erase(it);
			erase(it++);
		}
	}

5.拷贝构造

	void swap(list<T>& tmp)
	{
		std::swap(_head, tmp._head);
	}
	//拷贝构造
	list(const list<T>& lt)
	{
		//初始化
		_head = new node;
		_head->_next = _head;
		_head->_prev = _head;

		//复用区间构造
		list<T> tmp(lt.begin(), lt.end());
		swap(tmp);
	}

6.赋值重载

	void swap(list<T>& tmp)
	{
		std::swap(_head, tmp._head);
	}
	//赋值重载
	list<T>& operator=(list<T> lt)
	{
		swap(lt);
		return *this;
	}

四.源码

#include<iostream>
#include<assert.h>
using namespace std;
namespace dianxia
{
	//定义list节点
	template<class T>
	struct ListNode
	{
		struct ListNode<T>* _next; // 指向下一个结点
		struct ListNode<T>* _prev; // 指向前一个结点
		T _data; // 结点存储的数据

		ListNode(const T& data = T()) // 构造函数 // 申请一个节点 
			:_next(nullptr),
			_prev(nullptr),
			_data(data)
		{}
	};
	//迭代器的定义
	// 三个参数的含义分别为--数据类型T--T的引用--T的指针
	template<class T, class Ref, class Ptr> 
	struct _list_iterator
	{
		typedef ListNode<T> node;
		typedef _list_iterator<T, Ref, Ptr> self;
		node* _node;

		_list_iterator(node* node)
			:_node(node)
		{}

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

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

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

		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

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

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

		bool operator==(const self& s)
		{
			return _node == s._node;
		}

		bool operator!=(const self& s)
		{
			return _node != s._node;
		}
	};


	// list类的定义
	template<class T>
	class list
	{
		typedef ListNode<T> node;
	public:
		typedef _list_iterator<T, T&, T*> iterator;
		typedef _list_iterator<T, const T&, const T*> const_iterator;

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

		// 迭代器区间构造
		template<class Iterator>
		list(Iterator begin, Iterator end)
		{
			//初始化
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;

			while (begin != end)
			{
				push_back(*begin);
				++begin;
			}
		}
		void swap(list<T>& tmp)
		{
			std::swap(_head, tmp._head);
		}
		//拷贝构造
		list(const list<T>& lt)
		{
			//初始化
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;

			//复用区间构造
			list<T> tmp(lt.begin(), lt.end());
			swap(tmp);
		}

		//赋值重载
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		~list()
		{
			clean();
			delete _head;
			_head = nullptr;
		}

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

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

		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}

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

		void push_back(const T& data)
		{
			insert(end(),data);
		}

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

		void push_front(const T& data)
		{
			insert(begin(), data);
		}

		void pop_front()
		{
			erase(begin());
		}

		void insert(iterator pos, const T& data)
		{
			node* newNode = new node(data);

			node* cur = pos._node;
			node* prev = cur->_prev;

			newNode->_prev = prev;
			prev->_next = newNode;
			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 clean()
		{
			iterator it = begin();
			while (it != end())
			{
				//it = erase(it);
				erase(it++);
			}
		}
	private:
		node* _head;
	};
}


本文到此结束,码文不易,还请多多支持哦!!

  • 6
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
评论 6
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

殿下p

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

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

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

打赏作者

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

抵扣说明:

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

余额充值