void clear()
{
	Node* New = _head->_last;
	while (New != _head)
	{
		Node* News = New->_last;
		delete New;
		New = News;
	}
}

void swap(List<T>&l)
{
	std::swap(_head,l._head);
}

3.4.9list的迭代器失效

4. list与vector的对比

vector 与 list 都是 STL 中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

我的模拟源码仅供参考，第一次写，有错误欢迎在评论区指出

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;
template<class T>
struct ListNode//驼峰式命名
{
	ListNode<T>* _prev;
	ListNode<T>* _last;
	T _val;
	ListNode(const T &val=T())//缺省参数
		:_prev(nullptr)
	    ,_last(nullptr)
		,_val(val)
	{}
};

template <class T,class Ref,class Ptr>
struct ListIterator
{
	typedef ListNode<T> Node;//为了方便使用节点类，我们给它重命名一下
	typedef ListIterator<T, Ref,  Ptr>self;//原理同上
	ListIterator(Node* ptr)
		:_Node(ptr)
	{}
	Ref operator*()
	{
		return _Node->_val;
	}

	Ptr operator->()
	{
		return &_Node->val;
	 }
	self& operator++()
	{
		_Node = _Node->_last;
		return _Node;
	}

	self operator++(int)
	{
		Node* tmp = _Node;
		_Node = _Node->last;
		return tmp;
	}
	self operator--(int)
	{

		Node* tmp = _Node;
		_Node = _Node->_prev;
		return tmp;
	}
	self operator--()
	{
		_Node = _Node->_prev;
		return _Node;
	}
	bool operator==(self& s)
	{
		return _Node == s._Node;
	}
	bool operator!=(self& s)
	{
		return _Node != s._Node;
	}
	Node* _Node;
};
template<class T>
class List
{
public:
	typedef ListIterator<T, T&, T*> iterator;
	typedef ListIterator<T, const T&,const T*> const_iterator;
	typedef ListNode<T> Node;
	iterator begin()
	{
		return iterator(_head->_last);
	}
	const_iterator begin()const
	{
		return const_iterator(_head->_last);
	}
	iterator end()
	{
		return iterator(_head);
	}
	const_iterator end()const
	{
		return const_iterator(_head);
	}
	List(T val=T())
	:_head(new Node)
	{
		_head->_last = _head;
		_head->_prev = _head;
		_head->_val = val;
	}
	template <class InputIterator>
	List(InputIterator first, InputIterator last)
	{
		_head=new Node;
		_head->_last = _head;
		_head->_prev = _head;
		_head->_val = T();
		while (first != last)
		{
			push_back(*first);
			++first;
		}
	}

	~List()
	{
		clear();
		delete _head;
		_head = nullptr;
	}
	List(List<T>& l)
	{
		_head(new Node);
		_head->_last = _head;
		_head->_prev = _head;
		_head->_val = T();
		List<T>tmp(l.begin(), l.end());
		swap(tmp);
	}
	List<T>& operator=(List<T>l)
	{
		swap(l);
		return*this;
	}
	void intsert(iterator pos,T val)//原本在这个位置的节点向后移
	{
		Node* cur = pos._Node;
		Node* prev = cur->_prev;
		Node* NewNode = new Node(val);
		NewNode->_prev = prev;
		prev->_last = NewNode;
		NewNode->_last = cur;
		cur->_prev = NewNode;
	}
	void push_front(T val)
	{
		Node* NewNode = new Node(val);
		Node* last = _head->_last;
		NewNode->_prev = _head;
		NewNode->_last = last;
		last->_prev = NewNode;
		_head->_last = NewNode;
	}
	void  push_back(T val)
	{
		Node* NewNode = new Node(val);
		Node* tail = _head->_prev;
		tail->_last = NewNode;
		NewNode->_prev = tail;
		NewNode->_last = _head;
		_head->_prev = NewNode;
	}
	iterator erase(iterator pos)
	{
		assert(pos != end());
		Node* cur = pos._Node;
		Node* prev = cur->_prev;
		Node* last = cur->_last;
		prev->_last = last;
		last->_prev = prev;
		delete cur;
		return iterator(last);
	}
	void  pop_front()
	{
		erase(begin());
	}
	void pop_back()
	{
		erase(--end());
	}
	void clear()
	{
		Node* New = _head->_last;
		while (New != _head)
		{
			Node* News = New->_last;
			delete New;
			New = News;
		}
	}
	void swap(List<T>&l)
	{
		std::swap(_head,l._head);
	}
private:
	Node* _head;
};

总结

学习完list类，与之前相比，最大的收获就是迭代器的设计，同时也对多参数模板有了更深一步的了解，虽然过程艰辛，但是，List，over！

相信下一个难题也会被攻克

觉得有用的话，就点个赞支持一下吧😘😘😘