list详解

介绍：
list是带头双向循环链表，在链表的任意位置删除插入效率高，但不能像vector一样可以通过下标随机访问每个位置的元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，

list的使用（接口）
1、构造函数

list的打印：迭代器打印。范围auto打印

2、list 的iterator(迭代器）


begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

其他一些接口：



迭代器失效：list在insert时迭代器不会失效，但在erase时迭代器会失效

list的模拟实现：

#pragma once

#include
namespace bit
{
	template<class T>
		struct ListNode //构建每个链表节点
		{
			ListNode<T>* _next;
			ListNode<T>* _prev;
			T _date;

			ListNode(const T& x=T())//初始化节点
				:_next(nullptr)
				, _prev(nullptr)
				,_date(x)
			{
			}
		};
		
		template<class T>
		struct L //封装节点指针作为迭代器指针
		{
			typedef ListNode<T> Node;
			Node* _node;
			L(Node* node)
				:_node(node)
			{
				
			}

			//++it
			L& operator++()
			{
				_node = _node->_next;
				return *this;
			}
			//it++
			L& operator++(int)
			{
				L tmp = *this;
				_node = _node->_next;
				return tmp;
			}
			L& operator--()
			{
				_node = _node->_prev;
				return *this;
			}
			L& operator--(int)
			{
				L tmp = *this;
				_node = _node->_prev;
				return tmp;
			}

			T& operator*()
			{
				return _node->_date;
			}

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

				
		};


		
		
		template<class T>
		class List
		{
			typedef ListNode<T> Node;
		public:
			typedef L<T> iterator;
			iterator begin()
			{
				return iterator(_head->_next);
			}
			iterator end()
			{
				return iterator(_head);
			}
			//默认构造函数
			List()
			{
				_head = new Node;
				_head->_next = _head;
				_head->_prev = _head;
			}
			//拷贝构造
			//ist(const List& lt)
				List( List<T>& lt)
			{
				_head = new Node;
				_head->_next = _head;
				_head->_prev = _head;
				for (const auto& e : lt)
				{
					push_back(e);
				}
				
			}
			//尾插
			void push_back(const T& x=T())
			{
				/*Node* newnode = new Node(x);

				Node* tail = _head->_prev;
				tail->_next = newnode;
				newnode->_prev = tail;
				newnode->_next = _head;
				_head->_prev = newnode;*/
				insert(end(), x);


			}
			//头插
			void push_front(const T& x = T())
			{
				insert(begin(), x);
				
			}

			//插入
			iterator insert(iterator pos, const T& x)
			{
				Node* cur = pos._node;
				Node* prev = cur->_prev;
				Node* newnode = new Node(x);

				prev->_next = newnode;
				newnode->_prev = prev;
				newnode->_next = cur;
				cur->_prev = newnode;
				return iterator(newnode);

			}
			//删除pos位置的节点
			iterator erase(iterator pos)
			{
				assert(pos != end());
				Node* cur = pos._node;
				Node* prev = cur->_prev;
				Node* next = cur->_next;
				prev->_next = next;
				next->_prev = prev;

				delete cur;
				return next;
			}
			//尾删
			void  pop_back()
			{
				erase(--end());
			}

			//头删
			void pop_front()
			{
				erase(begin());
			}
			void clear()
			{
				iterator it = begin();
				while (it != end())
				{
					it = erase(it);
				}
			}
			~List()
			{
				clear();
				delete _head;
				_head = nullptr;

			}
			void swap(List<T>& tmp)
			{
				std::swap(_head, tmp._head);
			}
			List<T>& operator=(List<T> lt)
			{
				swap(lt);
				/*if (this != <)
				{
					clear();
					for (const auto& e : lt)
					{
						push_back(e);
					}
				}*/
				return *this;
			}

		private:
			Node* _head;//一个指链表的头指针
		};

		void test_List1()
		{


			List<int> lt;
			lt.push_back(1);
			lt.push_back(1);
			lt.push_back(1);
			lt.push_back(1);
			lt.push_front(3);
			for (auto e : lt)
			{
				cout << e;
			}
			cout << endl;

			List<int> lt2;

			lt2.push_back(1);
			lt2.push_back(2);
			lt2.push_back(3);
			lt2.push_back(4);
			lt2.push_front(5);

			for (auto e : lt2)
			{
				cout << e;
			}
			cout << endl;

			lt = lt2;

			for (auto e : lt)
			{
				cout << e;
			}
			cout << endl;
			/*List::iterator it = lt.end();
			while (it != lt.begin())
			{
				cout << *it;
				it--;
			}*/

			//for (auto e : lt)
			//{
			//	cout << e;
			//}
			//cout << endl;
			//lt.clear();
			


		}

}