C++List的简单模拟实现

C++List的简单模拟实现

1.引言

​ List是C++STL里的一种链式数据结构容器，底层是由带头双向循环链表实现的。得益于其在物理单元上非连续性的存储空间，在任意位置的插入删除相较于vector等容器性能有较大提升。由于其迭代器本身支持向前向后访问，但是不支持[]下标访问，所以属于双向迭代器。

​ 优点：1.可以在任意位置快速的删除插入数据。

​ 2.采用动态分配内存机制，不会造成内存浪费或者溢出。

​ 缺点：1.访问查询元素效率较低，每次查询都需要从头遍历链表。

​ 2.占用空间比较大。

本次List的模拟实现分为三个大部分来定义：List节点实现、迭代器实现和List类实现

​ 实现的主要功能有

​ 1.List节点定义以及初始化

​ 2.普通迭代器和const迭代器的实现以及运算符的重载

​ 3.List的初始化以及任意位置的插入删除

---

2. List节点实现

template<class T>	//适配各种数据类型采用定义模板
	struct ListNode
    {
		ListNode<T>* _next;	//一个节点定义前后指针以及数据这三个指标
		ListNode<T>* _prev;
		T _data;

		ListNode(const T& x = T())//采用匿名对象调用默认构造的方法
			:_next(nullptr)	//初始化列表初始成员
			,_prev(nullptr)
			,_data(x)
		{}

	};

由于我们想把ListNode链表节点里面的属性全部都开放出去，所以使用struct来定义一个对外部都开放的一个结构体。

定义next、prev和data这三个指标来完成一个节点的创建。

---

2.List迭代器实现

//Ref和Ptr参数是为了const迭代器套用同一份代码而产生的
//其中Ref是为了符号*的operator返回值 因为不知道是T& 还是constT&
//Ptr是为了符号->的operator返回值 因为不知道返回值是T* 还是 const 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* n)
			:_Node(n)
		{}

		Ref operator*()	//返回值为T&或者const T&
		{
			return _Node->_data;
		}

		Ptr operator->()	//返回值为T*或者const T*
		{
			return &_Node->_data;
		}

		self& operator++()
		{
			_Node = _Node->_next;
		}

		self operator++(int)
		{

			self tmp(*this);
			_Node = _Node->_next;	
			return tmp;
		}

		self& operator--()
		{
			_Node = _Node->_prev;
		}

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

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

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

这里由于考虑到普通迭代器和const迭代器的区别，所以为了避免就因为*与->返回值不同、别处都相同而再次copy一份大差不差的代码，采用了模板参数里面加上Ref指代引用&，和Ptr->指代返回指针类型。后面在List类里面就可以通过修改模板参数是否为const类型来达到复用同一份资源的目的。

3.List类实现

template<class T>
	class List
	{
	public:
		typedef ListNode<T> Node;
		typedef list_iterator<T, T&,T*> iterator;	//这里通过改变模板参数达到了构造出普通迭代器和const迭代器
		typedef list_iterator<T, const T&, const T*>const_iterator;
	public:
		

		List()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}

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

		iterator begin()
		{
			return iterator(_head->_next);
		}
		const_iterator end() const	//后一个const表示不能修改类的成员变量 前一个const表示只能通过const对象调用
		{
			return const_iterator(_head);
		}

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


		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				erase(it++);
				
			}
		}


		void insert(iterator pos, const T& x)
		{
			Node* cur = pos._Node;
			Node* prev = cur->_prev;

			Node* new_node = new Node(x);
			

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

		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& x)
		{
			insert(end(), x);
		}

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

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

		void push_front(const T& x)
		{
			inesrt(begin(), x);
		}
		~List()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
	private:
		Node* _head = nullptr;
	};

这里的默认插入是在pos位置的前面插入的。插入需要更改_next和 _prev属性，删除也需要更改并且需要delete掉当前的pos位置节点。

值得关注的是这里的erase删除函数需要返回一个，用于溯源到删除之前的节点位置（官方源码也是返回的iterator类型），否则可能会发生迭代器失效的问题。

4.迭代器失效问题

什么是迭代器失效问题？

首先，由于迭代器底层也是由指针设计而成，我们不妨把迭代器的操作想象成指针。

list迭代器失效即迭代器所指向的那个结点失效了，即该结点被删除了。因为list的底层结构为带头双向循环链表，并不是一个连续的结构。插入并不会导致迭代器的失效，不会扩容开辟新空间。只有在删除的时候才会失效，并且失效的只是指向被删除结点的迭代器，其它的迭代器并不会收到影响。

具体来说，由于List的非连续物理存储空间，一个节点被删除后 数据被删除了，但是指向该节点的迭代器并未更新导致变成了野指针，就可能导致内存泄露的问题，所以为了解决这个点我们才最好要再erase函数后面返回一个iteraor类型来溯源删除之前节点的位置。