【C++】STL---list的模拟实现

╰+攻爆jí腚メ 2024-03-30 17:35 11阅读 0赞

#### 目录 ####

*  前言
 *  一、list和vector的区别
 *  二、节点的定义
 *  三、list类定义
 *  四、push\_back函数
 *  五、push\_front函数
 *  六、迭代器
 *  七、begin和end函数
 *  八、迭代器区间初始化
 *  九、迭代器的操作符重载
 *   *  操作符++重载
     *  操作符- -重载
     *  操作符！=重载
     *  操作符==重载
     *  操作符\*重载
 *  十、insert函数
 *  十一、erase函数
 *  十二、pop\_back函数
 *  十三、pop\_front
 *  十四、析构函数
 *  十五、拷贝构造函数
 *  十六、赋值操作符重载
 *  十七、迭代器优化
 *  十七、反向迭代器
 *  总结:

## 前言 ##

上次模拟实现了一个vector容器，那么我们这次来实现一个list(链表)容器，链表在实际的开发中并不常见。但是也是一种很重要的数据结构，下面给大家介绍一下链表(list) 和 vector(顺序表)的区别。

--------------------

## 一、list和vector的区别 ##

> list 和 vector 一样，是一个存储容器。不同的是vector在内存中是连续存储的，而list每个节点所在的内存区域是不连续的。那我们用vector还是用list呢？vector和list的优劣势有以下几点。  
> vector优点:  
> 1.支持下标随机访问。  
> 2.cpu命中缓存率高  
> vector缺点:  
> 1.存在一定的程度的空间浪费。  
> 2.扩容代价大。  
> 3.中间和前面元素的删除与插入，代价大。  
>   
>   
> list优点:  
> 1.按需申请空间，不存在空间浪费。  
> 2.任意位置的插入与删除，时间复杂度都是O(1)。  
> list缺点:  
> 1.不支持随机访问，以至于查找，排序等操作代价太大。  
> 2.cpu命中缓存率低。  
>   
> 综上所述，我们可以看到list和vector是完全互补的两个容器。vector的优点就是list的缺点，vector的缺点就是list的优点。所以，如果查找多，用vector，如果增删操作多，用list，了解了list之后，接下来我们就可以模拟实现一下它。

--------------------

## 二、节点的定义 ##

我们要实现的是一个带头双向循环的链表。  
![在这里插入图片描述][62290d444bdf4531ba4c2420f38e7ea9.png]  
所以节点有三个参数，一个的prve指向前一个节点，一个是date存储数据，还有一个是next指向下一个节点。当然，我们还需要有个构造函数，来给date赋值。

代码:

//节点结构体
    	template<class T>
    	struct ListNode
    	{
        
    		typedef ListNode<T> Node;
    		Node* _prve;
    		Node* _next;
    		T _data;
    
    		//构造函数
    		ListNode():_prve(nullptr),_next(nullptr),_data(0){
        }
    		
    		ListNode(const T& val)
    			:_prve(nullptr)
    			,_next(nullptr)
    		{
        
    			_data = val;
    		}
    	};

--------------------

## 三、list类定义 ##

list定义很简单，因为要存任意类型的参数，我们用模板即可。  
而私有成员只有一个，那就是头节点。

代码:

template<class T>
    	class list
    	{
        
    		typedef ListNode<T> Node;
    	public:
    		//构造函数
    		list()
    		{
        
    			//开辟空间
    			_head = new Node;
    			//自己指向自己
    			_head->_prve = _head;
    			_head->_next = _head;
    		}
    	private:
    		Node* _head;
    	};

--------------------

## 四、push\_back函数 ##

push\_back函数也就是尾部插入，我们可以通过头节点的prev找到最后一个节点，随后链接即可。

代码:

void push_back(const T& val)
    		{
        
    			//创建一个新节点
    			Node* newNode = new Node(val);
    			//找到尾节点
    			Node* tail = _head->_prve;
    			//尾节点和创建的节点链接
    			tail->_next = newNode;
    			newNode->_prve = tail;
    			_head->_prve = newNode;
    			newNode->_next = _head;
    		}

--------------------

## 五、push\_front函数 ##

就是头插，很简单，直接保存节点的下一个节点，然后创建一个新节点。把这俩节点链接起来。

代码:

void push_front(const T& val)
    		{
        
    			//创建一个新节点
    			Node* newNode = new Node(val);
    			//保存头节点的下一个节点
    			Node* next = _head->_next;
    			//链接
    			_head->_next = newNode;
    			newNode->_prve = _head;
    			next->_prve = newNode;
    			newNode->_next = next;
    		}

## 六、迭代器 ##

因为是链表容器，链表在内存中的存储不是连续的，所以迭代器+1是无法找到下一个节点的。所以我们要单独弄一个结构体来封装list的迭代器。

代码:

template<class T>
    	struct_list_iterator
    	{
        
    		Node* _it;
    		typedef ListNode<T> Node;
    		// 构造函数
    		_list_iterator(Node* node)
    			:_it(node)
    		{
        	
    		}
    
    	};

--------------------

## 七、begin和end函数 ##

我们的链表是带头的，也就是头节点是不存放有效值的，所以头节点的\_next指向的节点就是链表的第一个节点。而最后一个节点的下一个节点又恰好是头节点。所以迭代器开始位置是在头节点的下一个位置，结束位置是头节点。不过再此之前，我们需要把迭代器typedef一下。

代码:

//迭代器
    		typedef _list_iterator<T> iterator;
    		typedef _list_iterator<const T> const_iterator;
    		//迭代器获取
    		iterator begin()
    		{
        
    			return iterator(_head->_next);
    		}
    
    		const_iterator begin()const
    		{
        
    			return const_iterator(_head->_next);
    		}
    
    		iterator end()
    		{
        
    			return iterator(_head);
    		}
    
    		const_iterator end()const
    		{
        
    			return const_iterator(_head);
    		}

## 八、迭代器区间初始化 ##

有了迭代器之后，我们可以用迭代器区间来进行初始化。

代码:

template<class InputIterator>
    		list(InputIterator first, InputIterator last)
    		{
        
    			//创建头节点
    			_head = new Node();
    			_head->_prve = _head;
    			_head->_next = _head;
    
    			while (first != last)
    			{
        
    				pusb_back(*first);
    				++first;
    			}
    		}

## 九、迭代器的操作符重载 ##

接下来我们来完善迭代器的一些操作。

### 操作符++重载 ###

迭代器++，就是指向下一个元素。

typedef _list_iterator<T> self;
    		//前置++重载
    		self& operator++()
    		{
        
    			_it = _it->_next;
    			return *this;
    		}
    		//后置++重载
    		self operator++(int)
    		{
        
    			self tmp(*this);
    			_it = _it->_next;
    			return tmp;
    		}

### 操作符- -重载 ###

和++类似，不过- -是到前一个节点。

//前置--重载
    		self& operator--()
    		{
        
    			_it = _it->_prve;
    			return *this;
    		}
    
    		//后置--重载
    		self operator--(int)
    		{
        
    			self tmp(*this);
    			_it = _it->_prve;
    			return tmp;
    		}

### 操作符！=重载 ###

直接比较地址即可。

// !=重载
    		bool operator!=(const self& it)const
    		{
        
    			return _it != it._it;
    		}

### 操作符==重载 ###

直接比较地址即可。

// ==重载
    		bool operator==(const self& it)const
    		{
        
    			return _it == it._it;
    		}

### 操作符\*重载 ###

\*就是解引用，所以我们返回节点的值即可。

T& operator*()
    		{
        
    			return _it->_data;
    		}

但是这个代码有个缺陷，那就是当容器是const的时候，依旧可以解引用修改它的值，这也就意味着const迭代器根本就不具有常属性，要想const迭代具备常属性，我们必须增加模板参数。  
![在这里插入图片描述][35003c5eff1c4d55aafd593751b6f286.png]  
当容器是const的时候，返回的const迭代器必须具有常属性。所以我们要加一个模板参数作为返回值。  
![在这里插入图片描述][f0552ea4c6644b59be616cb34a03fe90.png]

然后list里面typedef的类型也修改一下。  
![在这里插入图片描述][fe44a74b38204b0aa7204e7a3c0d94c1.png]  
然后我们解引用时，返回Ref这个模板参数  
![在这里插入图片描述][7f29a7a901e941db8231c8dcaea1b19c.png]  
这样，我们就让const的迭代器具备了常属性  
![在这里插入图片描述][bcf632ecabaf4f8e9540604b93b5b03a.png]  
迭代器结构体的所有代码:

//迭代器
    	template<class T,class Ref>
    	struct _list_iterator
    	{
        
    	
    		typedef ListNode<T> Node;
    		typedef _list_iterator<T,Ref> self;
    		Node* _it;
    		// 构造函数
    		_list_iterator(Node* node)
    			:_it(node){
        }
    		//前置++重载
    		self& operator++()
    		{
        
    			_it = _it->_next;
    			return *this;
    		}
    
    		//后置++重载
    		self operator++(int)
    		{
        
    			self tmp(*this);
    			_it = _it->_next;
    			return tmp;
    		}
    
    		//前置--重载
    		self& operator--()
    		{
        
    			_it = _it->_prve;
    			return *this;
    		}
    
    		//后置--重载
    		self operator--(int)
    		{
        
    			self tmp(*this);
    			_it = _it->_prve;
    			return tmp;
    		}
    		// *重载
    		Ref operator*()
    		{
        
    			return _it->_data;
    		}
    		// !=重载
    		bool operator!=(const self& it)const
    		{
        
    			return _it != it._it;
    		}
    		// ==重载
    		bool operator==(const self& it)const
    		{
        
    			return _it == it._it;
    		}
    
    	};

## 十、insert函数 ##

insert函数是在指定位置插入一个节点，那么我们可以用迭代器来接收这个要插入的位置。

//插入节点
    		iterator insert(iterator pos, const T& val)
    		{
        
    			assert(pos._it);
    			//保存pos的前一个位置
    			Node* cru = pos._it;
    			Node* prve = cru->_prve;
    			//创建节点
    			Node* newNode = new Node(val);
    			//链接
    			prve->_next = newNode;
    			newNode->_prve = prve;
    			newNode->_next = cru;
    			cru->_prve = newNode;
    
    			return pos;
    		}

## 十一、erase函数 ##

指定位置删除节点，删除节点会影响迭代器失效，所以要返回一个有效的迭代器。删除操作也十分简单，保存前一个节点的地址和后一个地址的节点，然后链接这2个节点，之后释放pos节点。

iterator erase(iterator pos)
    		{
        
    			assert(pos._it);
    			Node* cru = pos._it;
    			Node* prve = cru->_prve;
    			Node* next = cru->_next;
    			//链接
    			prve->_next = next;
    			next->_prve = prve;
    			//释放cru
    			delete cru;
    			return next;
    		}

## 十二、pop\_back函数 ##

就是尾删，我们可以直接复用erase

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

当然，push\_back也可以复用inset

## 十三、pop\_front ##

就是头删，还是复用erase。头插也可以复用insert

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

## 十四、析构函数 ##

链表的基本功能已经实现完了，但是当我们链表不用的时候，申请的空间必须销毁。而自带的析构函数不会销毁动态申请的空间，需要我们自己写析构函数销毁。

代码:

//析构函数
    		~list()
    		{
        
    			//清空链表
    			clear();
    			//释放头节点
    			delete _head;
    			_head = nullptr;
    		}
    
    		void clear()
    		{
        
    			//除了头节点外，其他都释放。
    			iterator it = begin();
    			while (it != end())
    			{
        
    				//保存下一个位置的地址
    				iterator next = it++;
    				delete next._it;
    			}
    			//释放完之后，头节点指向的是个野指针，所以我们让它指向自己
    			_head->_next = _head;
    			_head->_prve = _head;
    		}

## 十五、拷贝构造函数 ##

那么我们想拷贝链表呢？我们可以直接用迭代器区间去创建一个新的对象，然后把新对象的头节点成员和旧对象进行交换。出了函数创建的对象会自动调用析构函数释放空间。

//拷贝构造
    		list(const list<T>& l1)
    		{
        
    			//创建头节点
    			_head = new Node();
    			_head->_prve = _head;
    			_head->_next = _head;
    			//创建新对象，利用迭代器区间
    			list<T> tmp(l1.begin(), l1.end());
    			//随后交换新对象和旧对象的成员
    			swap(_head, tmp._head);
    		}

## 十六、赋值操作符重载 ##

我们可以利用拷贝构造创建一个新对象，然后交换头节点。函数结束，创建的对象自动析构。

代码:

list<T>& operator=(const list<T>& l1)
    		{
        
    			list<T> tmp(l1);
    			swap(_head, tmp._head);
    			return *this;
    		}

## 十七、迭代器优化 ##

我们的迭代器还不够完美，因为如果list装的是自定义类型的话，我们还需要让迭代器支持 ->访问。期望它返回一个对象的指针回来，然后该对象的指针可以->直接访问成员。所以我们还需要增加模板参数。

增加一个指针参数  
![在这里插入图片描述][4bd1e0fae2da40228d1f1dafa78f1747.png]  
链表里的迭代器调整。  
![在这里插入图片描述][5a83a6901b644d3aa28c5b99775c62d6.png]  
然后重载 迭代器的->操作符

Ptr operator->()
    		{
        
    			//返回对象的指针
    			return &(_it->_data);
    		}

可以直接支持->访问  
![在这里插入图片描述][7d3da0761e2c43fe93bd3a9857a6b294.png]

## 十七、反向迭代器 ##

之前在vector实现的时候，我们实现过反向迭代器。[vector实现链接][vector]。所以我们可以复用这个反向迭代器。

首先，包上反向迭代器的头文件名。  
![在这里插入图片描述][c59f29d0dbd04443b57157496040ada9.png]  
其次，我们typedef 2个反向迭代器  
![在这里插入图片描述][63f431e1df7b47c8af4391da7831b2e3.png]

随后用rbegin函数和rend函数获取迭代器的开始和结束位置。  
begin返回的是从头节点的下一个节点，所以rend就是返回头节点的下一个位置。  
end返回的是头节点，所以rbegin返回头节点。

代码:

//反向迭代器获取
    		reverse_iterator rbegin()
    		{
        
    			return reverse_iterator(end());
    		}
    
    		reverse_iterator rend()
    		{
        
    			return reverse_iterator(begin());
    		}
    
    		const_reverse_iterator rbegin()const
    		{
        
    			return reverse_const_iterator(end());
    		}
    
    		const_reverse_iterator rend()const
    		{
        
    			return reverse_const_iterator(begin());
    		}

全部代码:  
list.h代码

#pragma once
    #include "reverse_iterator.h"
    
    namespace wyl
    {
        
    	//节点结构体
    	template<class T>
    	struct ListNode
    	{
        
    		typedef ListNode<T> Node;
    		Node* _prve;
    		Node* _next;
    		T _data;
    
    		//构造函数
    		ListNode():_prve(nullptr),_next(nullptr),_data(0){
        }
    
    		ListNode(const T& val)
    			:_prve(nullptr)
    			,_next(nullptr)
    		{
        
    			_data = val;
    		}
    	};
    
    	//迭代器
    	template<class T,class Ref,class Ptr>
    	struct _list_iterator
    	{
        
    	
    		typedef ListNode<T> Node;
    		typedef _list_iterator<T,Ref,Ptr> self;
    		Node* _it;
    		// 构造函数
    		_list_iterator(Node* node)
    			:_it(node){
        }
    		//前置++重载
    		self& operator++()
    		{
        
    			_it = _it->_next;
    			return *this;
    		}
    
    		//后置++重载
    		self operator++(int)
    		{
        
    			self tmp(*this);
    			_it = _it->_next;
    			return tmp;
    		}
    
    		//前置--重载
    		self& operator--()
    		{
        
    			_it = _it->_prve;
    			return *this;
    		}
    
    		//后置--重载
    		self operator--(int)
    		{
        
    			self tmp(*this);
    			_it = _it->_prve;
    			return tmp;
    		}
    		// *重载
    		Ref operator*()
    		{
        
    			return _it->_data;
    		}
    		// !=重载
    		bool operator!=(const self& it)const
    		{
        
    			return _it != it._it;
    		}
    		// ==重载
    		bool operator==(const self& it)const
    		{
        
    			return _it == it._it;
    		}
    
    		Ptr operator->()
    		{
        
    			//返回对象的指针
    			return &(_it->_data);
    		}
    
    	};
    
    	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;
    		//反向迭代器
    		typedef _reverse_iterator<iterator, T&, T*> reverse_iterator;
    		typedef _reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
    
    		//构造函数
    		list()
    		{
        
    			//开辟空间
    			_head = new Node();
    			//自己指向自己
    			_head->_prve = _head;
    			_head->_next = _head;
    		}
    		//迭代器区间初始化
    		template<class InputIterator>
    		list(InputIterator first, InputIterator last)
    		{
        
    			//创建头节点
    			_head = new Node();
    			_head->_prve = _head;
    			_head->_next = _head;
    
    			while (first != last)
    			{
        
    				push_back(*first);
    				++first;
    			}
    		}
    		//拷贝构造
    		list(const list<T>& l1)
    		{
        
    			//创建头节点
    			_head = new Node();
    			_head->_prve = _head;
    			_head->_next = _head;
    			//创建新对象，利用迭代器区间
    			list<T> tmp(l1.begin(), l1.end());
    			//随后交换新对象和旧对象的成员
    			swap(_head, tmp._head);
    		}
    		list<T>& operator=(const list<T>& l1)
    		{
        
    			list<T> tmp(l1);
    			swap(_head, tmp._head);
    			return *this;
    		}
    
    		//析构函数
    		~list()
    		{
        
    			//清空链表
    			clear();
    			//释放头节点
    			delete _head;
    			_head = nullptr;
    		}
    
    		void clear()
    		{
        
    			//除了头节点外，其他都释放。
    			iterator it = begin();
    			while (it != end())
    			{
        
    				//保存下一个位置的地址
    				iterator next = it++;
    				delete next._it;
    			}
    			//释放完之后，头节点指向的是个野指针，所以我们让它指向自己
    			_head->_next = _head;
    			_head->_prve = _head;
    		}
    
    		void push_back(const T& val)
    		{
        
    			//创建一个新节点
    			Node* newNode = new Node(val);
    			//找到尾节点
    			Node* tail = _head->_prve;
    			//尾节点和创建的节点链接
    			tail->_next = newNode;
    			newNode->_prve = tail;
    			_head->_prve = newNode;
    			newNode->_next = _head;
    		}
    
    		void push_front(const T& val)
    		{
        
    			//创建一个新节点
    			Node* newNode = new Node(val);
    			//保存头节点的下一个节点
    			Node* next = _head->_next;
    			//链接
    			_head->_next = newNode;
    			newNode->_prve = _head;
    			next->_prve = newNode;
    			newNode->_next = next;
    		}
    
    
    
    		//迭代器获取
    		iterator begin()
    		{
        
    			return iterator(_head->_next);
    		}
    
    		const_iterator begin()const
    		{
        
    			return const_iterator(_head->_next);
    		}
    
    		iterator end()
    		{
        
    			return iterator(_head);
    		}
    
    		const_iterator end()const
    		{
        
    			return const_iterator(_head);
    		}
    
    		//反向迭代器获取
    		reverse_iterator rbegin()
    		{
        
    			return reverse_iterator(end());
    		}
    
    		reverse_iterator rend()
    		{
        
    			return reverse_iterator(begin());
    		}
    
    		const_reverse_iterator rbegin()const
    		{
        
    			return const_reverse_iterator(end());
    		}
    
    		const_reverse_iterator rend()const
    		{
        
    			return const_reverse_iterator(begin());
    		}
    
    
    		//插入节点
    		iterator insert(iterator pos, const T& val)
    		{
        
    			assert(pos._it);
    			//保存pos的前一个位置
    			Node* cru = pos._it;
    			Node* prve = cru->_prve;
    			//创建节点
    			Node* newNode = new Node(val);
    			//链接
    			prve->_next = newNode;
    			newNode->_prve = prve;
    			newNode->_next = cru;
    			cru->_prve = newNode;
    
    			return pos;
    		}
    
    		iterator erase(iterator pos)
    		{
        
    			assert(pos._it);
    			Node* cru = pos._it;
    			Node* prve = cru->_prve;
    			Node* next = cru->_next;
    			//链接
    			prve->_next = next;
    			next->_prve = prve;
    			//释放cru
    			delete cru;
    			return next;
    		}
    		
    		void pop_back()
    		{
        
    			erase(end());
    		}
    
    		void pop_front()
    		{
        
    			erase(begin());
    		}
    
    	private:
    		Node* _head;
    	};
    
    
    	//--------------------------------------------------------------------------------------------
    	//以下是测试内容
    
    	void listTest1()
    	{
        
    		list<int> l;
    		l.push_back(1);
    		l.push_back(2);
    		l.push_back(3);
    		l.push_front(30);
    		l.push_front(20);
    		l.push_front(10);
    	}
    
    	void a(const list<int>& l)
    	{
        
    		list<int>::const_iterator it = l.begin();
    		while (it != l.end())
    		{
        
    			//*it = 5;
    			cout << *it << " ";
    			it++;
    		}
    	}
    
    	void listTest2()
    	{
        
    		list<int> l;
    		l.push_back(1);
    		l.push_back(2);
    		l.push_back(3);
    		list<int>::iterator it = l.begin();
    		while (it != l.end())
    		{
        
    			*it = 55;
    			cout << *it << " ";
    			++it;
    		}
    		//a(l);
    	}
    
    	void listTest3()
    	{
        
    		list<int> l;
    		l.push_back(1);
    		l.push_back(2);
    		l.push_back(4);
    		l.push_back(5);
    		l.insert(l.begin(),100);
    		l.insert(l.end(), 10);
    
    		list<int>::iterator it = l.begin();
    		while (it != l.end())
    		{
        
    			if (*it % 2 == 0)
    			{
        
    				it = l.erase(it);
    			}
    			else
    				++it;
    		}
    		it = l.begin();
    		while (it != l.end())
    		{
        
    			cout << *it << " ";
    			++it;
    		}
    	}
    
    	void listTest4()
    	{
        
    		list<int> l;
    		l.push_back(1);
    		l.push_back(2);
    		l.push_back(4);
    		l.push_back(5);
    		l.clear();
    		l.push_back(1);
    		l.push_back(2);
    		l.push_back(4); 
    		l.push_back(5);
    		list<int> l2 = l;
    		list<int>::iterator it = l2.begin();
    		while (it != l2.end())
    		{
        
    			cout << *it << " ";
    			++it;
    		}
    	}
    
    
    	void listTest5()
    	{
        
    		list<Date> l;
    		l.push_back(Date(2022, 1, 3));
    		l.push_back(Date(2022, 1, 4));
    		l.push_back(Date(2022, 1, 5));
    
    		list<Date>::iterator it = l.begin();
    		while (it != l.end())
    		{
        
    			cout << it->_year << "/"<<it->_month<<"/"<<it->_day<<endl;
    			++it;
    		}
    
    	}
    
    	void listTest6()
    	{
        
    		list<Date> l;
    		l.push_back(Date(2022, 1, 3));
    		l.push_back(Date(2022, 1, 4));
    		l.push_back(Date(2022, 1, 5));
    
    		list<Date>::reverse_iterator it = l.rbegin();
    		while (it != l.rend())
    		{
        
    			cout << it->_year << "/" << it->_month << "/" << it->_day << endl;
    			++it;
    		}
    
    	}
    
    }

反向迭代器代码:  
reverse\_iterator.h

#pragma once
    
    template<class iterator,class Ref,class Ptr>
    class _reverse_iterator
    {
        
    	typedef _reverse_iterator<iterator, Ref, Ptr> self;
    public:	
    	_reverse_iterator(iterator it)
    		:_it(it)
    	{
        }
    	//前置++
    	self& operator++()
    	{
        
    		--_it;
    		return *this;
    	}
    	//后置++
    	self operator++(int)
    	{
        
    		self tmp(*this);
    		--_it;
    		return tmp;
    	}
    
    	//前置--
    	self& operator--()
    	{
        
    		++_it;
    		return *this;
    	}
    	//后置--
    	self operator--(int)
    	{
        
    		self tmp(*this);
    		++_it;
    		return tmp;
    	}
    
    	Ref operator*()
    	{
        
    		iterator tmp = (*this)._it;
    		return *(--tmp);
    	}
    
    	Ptr operator->()
    	{
        
    		return &operator*();
    	}
    
    	bool operator!=(const self& it)
    	{
        
    		return _it != it._it;
    	}
    
    	bool operator!=(const self& it)const
    	{
        
    		return _it != it._it;
    	}
    
    	bool operator==(const self& it)
    	{
        
    		return _it == it._it;
    	}
    
    	bool operator==(const self& it)const
    	{
        
    		return _it == it._it;
    	}
    
    
    private:
    	iterator _it;
    };

主程序代码:

#include"list.h"
    void listTest()
    {
        
    	//wyl::listTest2();
    	//wyl::listTest3();
    	//wyl::listTest4();
    	//wyl::listTest5();
    	wyl::listTest6();
    
    }
    
    int main()
    {
        
    	listTest();
    
    }

## 总结: ##

list的实现，其实最主要的部分还是迭代器。list的迭代器是比较特殊的，因为list在内存中不是连续存储的。以上代码都是我边打，边测试，没问题了才会发出来。如果有什么没测试到的错误，欢迎大家指出。以后会持续为大家更新STL的内容，以及数据结构，C语言，linux等方面的内容。感谢大家的支持，如果感觉写的还不错，麻烦给个三连嘛。我会多多努力的！

[62290d444bdf4531ba4c2420f38e7ea9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/52c8d4af33134a9d98e70fe69dc10a08.png
[35003c5eff1c4d55aafd593751b6f286.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/29e69117aee84cfb888c8a0dbd024022.png
[f0552ea4c6644b59be616cb34a03fe90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/94abce134cd44d4eb15104f7cab9e45e.png
[fe44a74b38204b0aa7204e7a3c0d94c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/35b6080c3ed747aea3f0710e8c669968.png
[7f29a7a901e941db8231c8dcaea1b19c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0491ee29da5b42c7b7e49aa809f615ed.png
[bcf632ecabaf4f8e9540604b93b5b03a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/06821211b8f34db8923705db423b3b1c.png
[4bd1e0fae2da40228d1f1dafa78f1747.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c529c0f53af844fc842b9fa4874c73b6.png
[5a83a6901b644d3aa28c5b99775c62d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3c2c61cf073d4e5baab4d943c72edd24.png
[7d3da0761e2c43fe93bd3a9857a6b294.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4fa02749c6f3493db2316645fd4624cb.png
[vector]: http://t.csdn.cn/JXwKh
[c59f29d0dbd04443b57157496040ada9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/58669d086af44742a45eb81c59c023be.png
[63f431e1df7b47c8af4391da7831b2e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e891a5cb93c94d33bef91240db824df8.png