list源碼實現（insert，list，push_back,push_front,pop_back,pop_front,erase,insert,iterator）

 

#pragma once
namespace lxh
{
	template<class T>
	class ListNode
	{
	public:
		/* 鏈表節點 */
		T m_val;
		ListNode * p_prev;
		ListNode * p_next;
		ListNode(const T & val=T()) :p_next(nullptr), p_prev(nullptr), m_val(val)
		{

		}

	};
	template<class T>
	class list
	{
		/* 私有造頭 */
		ListNode<T>* m_head;
		void creadHead()
		{
			/* 開闢空間,並且生成鏈表 */
			m_head = new ListNode<T>;
			m_head->p_next = m_head->p_prev = m_head;
		}
	public:
		/* 內部類 ，省去了友元或者聲明的麻煩，更有利於閱讀吧*/
		class iterator
		{
			/* 因爲鏈表是用戶自定義的數據結構所以，他不像容器，string類一樣，
			使用的是int double char等系統內置好的，已經明確的知道內存大小的數據類型，
			所以要對鏈表進行遍歷的時候，除了使用用戶自己寫的for循環外，
			還有iterator迭代器，它是一個類，此時需要我們自己手動實現這個類，才能使用他*/
		public:
			/* 作爲一種指針首先它需要一個鏈表節點的指針 */
			ListNode<T> * m_pos;
			iterator(ListNode<T>* val = nullptr)
				:m_pos(val)
			{
				/* 構造函數 */
			}
			/*下面就是關於迭代器的一些重載 */
			T& operator*()
			{
				return m_pos->m_val;
			}
			T &operator->()
			{
				return &m_pos->m_val;
			}
			iterator operator++()
			{
				m_pos = m_pos->p_next;
				return *this;/* m_pos */
			}
			iterator operator++(int)
			{
				/* 後加 */
				iterator tmp = m_pos;
				m_pos = m_pos->p_next;
				return tmp;
			}
			iterator operator--()
			{
				m_pos = m_pos->p_prev;
				return *this;/* m_pos */
			}
			iterator operator--(int)
			{
				/* 後加 */
				iterator tmp = m_pos;
				m_pos = m_pos->p_prev;
				return tmp;
			}

			bool operator==(const iterator & tmp)
			{
				return m_pos = tmp.m_pos;
			}
			bool operator!=(const iterator & tmp)
			{
				return m_pos != tmp.m_pos;
			}
			 
		};
		/* 如上作爲內部類的迭代器初步完成，接下來是list的一些操作 */
		/* list構造函數 */
		list()
		{
			creadHead();
		}
		list(int n, const T & val=T())
		{
			/* 構造n個val */
			creadHead();
			for (int i=0;i<n;++i)
			{
				push_back(val);
			}
		}
		list(iterator _begin, iterator _end)
		{
			/* 用另一個鏈表的一段，初始化鏈表 */
			creadHead();
			insert(end(), _begin, _end);
		}
		list(T* _begin, T*_end)
		{
			creadHead();
			insert(end(), _begin, _end);
		}
		list(list & l)
		{
			insert(end(), l.begin(), l.end());
		}
		~list()
		{
			erase(begin(), end());
			delete m_head;
		}
		void clear()
		{
			erase(begin(), end());

		}
		void push_back(const T & val)
		{
			/* 在頭後插 */
			insert(end(),val);
		}
		void push_front(const T & val)
		{
			/* 在頭前插 */
			insert(begin(), val);
		}
		void pop_back()
		{
			erase(--end());
		}
		void pop_front()
		{
			erase(begin());
		}
		iterator begin()
		{
			return m_head->p_next;
		}
		iterator end()
		{
			return m_head;
		}
		iterator insert(iterator pos, T* _begin, T*_end)
		{
			T* tmp;
			iterator tag = --pos;
			pos++;
			for (tmp = _begin; tmp != _end; ++tmp)
			{
				insert(pos, *tmp);
			}
			return ++tag;
		}

		iterator insert(iterator pos, iterator _begin,iterator _end)
		{
			iterator tmp;
			iterator tag = --pos;
			pos++;
			for (tmp=_begin;tmp!=_end;++tmp)
			{
				insert(pos, *tmp);
			}
			return ++tag;
		}
		iterator insert(iterator pos, const T & val)
		{
			/* 插入函數，給定位置和值 */
			/* 首先要一個新的鏈表節點 */
			ListNode<T>* cur = new ListNode<T>;
			ListNode<T>* npos = pos.m_pos;/* 從位置數到指針位置的轉換 */
			cur->m_val = val;
			
			cur->p_prev = npos->p_prev;
			cur->p_prev->p_next = cur;
			
			cur->p_next = npos;
			npos->p_prev = cur;
			
			return cur;
		}
		iterator erase(iterator pos)
		{
			ListNode<T>* npos = pos.m_pos;/* 轉數字爲節點指針 */
			ListNode<T>* res = npos->p_next;/*  指針指向的對象已經無效了*/
			npos->p_prev->p_next = npos->p_next;
			npos->p_next->p_prev = npos->p_prev;
			delete npos;


			npos = nullptr;
			return res;
		}
		iterator erase(iterator start, iterator finsh)
		{
			iterator i;
			//iterator tmp = ++finsh;
			for (i = start; i != finsh;  )
			{
				i=erase(i);
			}
			 
			return finsh;
		}
	};

}