list()		//無(wú)參默認(rèn)構(gòu)造函數(shù)
{
	this->m_head = new node(T());
	this->m_head->m_next = this->m_head;	//創(chuàng)建頭結(jié)點(diǎn)，并讓頭結(jié)點(diǎn)的頭尾相連形成循環(huán)結(jié)構(gòu)
	this->m_head->m_prev = this->m_head;
}

list(size_t size, const T& val=T())	//n個(gè)元素構(gòu)造函數(shù)
{
	this->m_head = new node(T());	//創(chuàng)建頭結(jié)點(diǎn)，并讓頭結(jié)點(diǎn)的頭尾相連形成循環(huán)結(jié)構(gòu)
	this->m_head->m_next = this->m_head;
	this->m_head->m_prev = this->m_head;
	while (size--)
	{
		this->push_back(val);
	}
}

list(long size, const T& val = T())	//n個(gè)元素構(gòu)造函數(shù)
{
	assert(size > 0);
	this->m_head = new node(T());	//創(chuàng)建頭結(jié)點(diǎn)，并讓頭結(jié)點(diǎn)的頭尾相連形成循環(huán)結(jié)構(gòu)
	this->m_head->m_next = this->m_head;
	this->m_head->m_prev = this->m_head;
	while (size--)
	{
		this->push_back(val);
	}
}

list(int size, const T& val = T())	//n個(gè)元素構(gòu)造函數(shù)
{
	assert(size > 0);
	this->m_head = new node(T());	//創(chuàng)建頭結(jié)點(diǎn)，并讓頭結(jié)點(diǎn)的頭尾相連形成循環(huán)結(jié)構(gòu)
	this->m_head->m_next = this->m_head;
	this->m_head->m_prev = this->m_head;
	while (size--)
	{
		this->push_back(val);
	}
}

ZJ::list<int>L(2,1);	//不實(shí)現(xiàn)重載版本會(huì)調(diào)用到模板區(qū)間構(gòu)造函數(shù)

template <class InputIterator>
list(InputIterator first, InputIterator last)		//區(qū)間構(gòu)造
{
	this->m_head = new node(T());	//創(chuàng)建頭結(jié)點(diǎn)
	this->m_head->m_next = this->m_head;
	this->m_head->m_prev = this->m_head;
	while (first != last)
	{
		node* newnode = new node(*first);
		node* tail = this->m_head->m_prev;
		tail->m_next = newnode;
		newnode->m_prev = tail;
		newnode->m_next = this->m_head;
		this->m_head->m_prev = newnode;
		++first;
	}
}

list(const list<T>& obj)		//拷貝構(gòu)造函數(shù)
{
	this->m_head = new node(T());	//創(chuàng)建頭結(jié)點(diǎn)，并讓頭結(jié)點(diǎn)的頭尾相連形成循環(huán)結(jié)構(gòu)
	this->m_head->m_next = this->m_head;
	this->m_head->m_prev = this->m_head;
	const_iterator it = obj.begin();
	while (it != obj.end())
	{
		node* newnode = new node(it.m_pnode->m_val);	//創(chuàng)建新結(jié)點(diǎn)并把值賦予給它

		node* tail = this->m_head->m_prev;
		tail->m_next = newnode;
		newnode->m_prev = tail;
		newnode->m_next = this->m_head;
		this->m_head->m_prev = newnode;
		++it;
	}
}

list<T>& operator=(const list<T>& obj)		//賦值運(yùn)算符重載
{
	if (this != &obj)	//防止自我賦值
	{
		list<T>temp(obj);
		this->swap(temp);
	}
	return *this;		//返回自己
}

~list()		//析構(gòu)函數(shù)
{
	iterator it = this->begin();

	while (it != this->end())	//復(fù)用我們寫(xiě)的頭刪，一個(gè)一個(gè)的刪除，當(dāng)然也可以復(fù)用尾刪pop_back()和erase()
	{
		++it;
		this->pop_front();
	}

	delete this->m_head;
	this->m_head = nullptr;
}

iterator begin()
{
	return iterator(this->m_head->m_next);
}

const_iterator begin()	const
{
	return const_iterator(this->m_head->m_next);
}

iterator end()
{
	return iterator(this->m_head);
}

const_iterator end()	const
{
	return const_iterator(this->m_head);
}

typedef list_iterator<T,T&,T*> iterator;		//普通迭代器
typedef list_iterator<T,const T&,const T*> const_iterator;	//常量迭代器

list_iterator(node* pnode)
			:m_pnode(pnode)
		{}

ZJ::list<int>::iterator it = L1.begin();
it != L1.end()

bool operator!=(const myself&obj) const		//重載！=號(hào)
{
	return this->m_pnode != obj.m_pnode;
}

bool operator==(const myself& obj) const	//重載==號(hào)
{
	return this->m_pnode == obj.m_pnode;
}

typedef list_iterator<T, Ref, Ptr>myself;

myself& operator++()		//重載前置++
{
	//由于我們的list是雙向循環(huán)鏈表，我們的++，就是指向下一個(gè)結(jié)點(diǎn)
	this->m_pnode = this->m_pnode->m_next;
	return *this;
}

myself operator++(int)		//重載后置++
{
	const myself temp(*this);
	this->m_pnode = this->m_pnode->m_next;
	return temp;
}

myself& operator--()		//重載前置--
{
	//由于我們的list是雙向循環(huán)鏈表，我們的--就是得到它上一個(gè)結(jié)點(diǎn)的迭代器
	this->m_pnode = this->m_pnode->m_prev;
	return *this;
}

myself operator--(int)		//重載后置--
{
	const myself temp(*this);
	this->m_pnode = this->m_pnode->m_prev;
	return temp;
}

Ref operator* ()		//重載  *
{
	return this->m_pnode->m_val;
}

Ptr operator->()		//重載 ->
{
	return &this->m_pnode->m_val;
}

bool empty()	const		//判空
{
	return this->begin() == this->end();	//就是begin()與end()同時(shí)指向頭結(jié)點(diǎn)時(shí)的情況
}

//遍歷一遍鏈表來(lái)得到元素個(gè)數(shù)，為什么使用遍歷一遍鏈表呢？
//這是因?yàn)槲覀兪褂面湵頃r(shí)很少會(huì)去知道它的元素個(gè)數(shù)，但如果頻繁的調(diào)用該接口會(huì)造成性能的下降
//此時(shí)我們應(yīng)該在list類(lèi)中將增加一個(gè)記錄元素個(gè)數(shù)的變量size
//如果有元素插入就增加，刪除就減少
size_t size()	const	//獲得元素個(gè)數(shù)
{
	size_t size = 0;
	const_iterator it = this->begin();
	while(it!=this->end())
	{
		++it;
		++size;
	}
	return size;
}

T& back()
{
	assert(!this->empty());
	return this->m_head->m_prev->m_val;
}

const T& back()   const
{
	assert(!this->empty());
	return this->m_head->prev->m_val;
}

T& front()
{
	assert(!this->empty());
	return  this->m_head->m_next->m_val;
}

const T& front() const
{
	assert(!this->empty());
	return this->m_head->m_next->m_val;
}

void push_back(const T& val)	//尾插
{
	node* tail = this->m_head->m_prev;	//指向尾部結(jié)點(diǎn)
	node* newnode = new node(val);		//創(chuàng)建新結(jié)點(diǎn)
	newnode->m_next = tail->m_next;		//將新結(jié)點(diǎn)的m_next指向頭結(jié)點(diǎn)
	newnode->m_prev = tail;				//將新結(jié)點(diǎn)m_prev指向tail結(jié)點(diǎn)
	tail->m_next = newnode;				//并將原來(lái)的尾結(jié)點(diǎn)的m_next指向newnode
	this->m_head->m_prev = newnode;		//并將頭結(jié)點(diǎn)的m_prev指向新的尾
}

void push_front(const T& val)	//頭插
{
	node* newnode = new node(val);	//創(chuàng)建新結(jié)點(diǎn)
	node*  next = this->m_head->m_next;	//指向第一個(gè)結(jié)點(diǎn)
	newnode->m_next = next;		//將創(chuàng)建的新結(jié)點(diǎn)newnode的m_next指向我們?cè)瓉?lái)的第一個(gè)元素next
	this->m_head->m_next = newnode;	//在將我們的頭結(jié)點(diǎn)的m_next指向新創(chuàng)建的結(jié)點(diǎn)
	newnode->m_prev = this->m_head;	//在將新結(jié)點(diǎn)的m_prev指向頭結(jié)點(diǎn)
	next->m_prev = newnode;	//在將原先第一個(gè)結(jié)點(diǎn)元素的m_prev指向新創(chuàng)建的結(jié)點(diǎn)
}

void pop_back()		//尾刪
{
	assert(!empty());	//斷言 如果list已經(jīng)為空，則刪除不了
	node* tail = this->m_head->m_prev;	//先找到我們要?jiǎng)h除的尾結(jié)點(diǎn)
	node* prev = tail->m_prev;		//再找到要?jiǎng)h除的尾結(jié)點(diǎn)的前一個(gè)結(jié)點(diǎn)
	this->m_head->m_prev = prev;	//將頭結(jié)點(diǎn)的m_prev指向新的尾prev
	prev->m_next = this->m_head;	//再將prev的m_next指向頭結(jié)點(diǎn)
	tail->m_next = tail->m_prev = nullptr;	//把要?jiǎng)h除的元素的成員至nullptr
	tail->m_val = T();		//將要?jiǎng)h除的元素的值置為匿名對(duì)象的默認(rèn)值
	delete tail;			//刪除尾結(jié)點(diǎn)
}

void pop_front()	//頭刪
{
	assert(!empty());	//斷言 如果list已經(jīng)為空，則刪除不了
	node* delnode = this->m_head->m_next;	//先找到我們要?jiǎng)h除的第一個(gè)結(jié)點(diǎn)位置
	node* next = delnode->m_next;			//在找到刪除結(jié)點(diǎn)的下一個(gè)結(jié)點(diǎn)的位置
	this->m_head->m_next = next;			//再將頭結(jié)點(diǎn)的m_next指向我們新的第一個(gè)結(jié)點(diǎn)
	next->m_prev = this->m_head;			//再將我們的新的第一個(gè)結(jié)點(diǎn)的m_prev指向頭結(jié)點(diǎn)
	delnode->m_next = delnode->m_prev = nullptr;	//把要?jiǎng)h除的元素的成員至nullptr
	delnode->m_val = T();		//將要?jiǎng)h除的元素的值置為匿名對(duì)象的默認(rèn)值
	delete delnode;		//刪除第一個(gè)結(jié)點(diǎn)
}

//插入元素到指定位置，返回的是插入的元素的迭代器
iterator insert(iterator pos, const T& val)
{
	assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
	node* newnode = new node(val);		//創(chuàng)建新結(jié)點(diǎn)

	node* cur = pos.m_pnode;		//記錄當(dāng)前結(jié)點(diǎn)的指針
	node* prev = cur->m_prev;		//記錄當(dāng)前結(jié)點(diǎn)的前一個(gè)結(jié)點(diǎn)的指針

	newnode->m_next = cur;
	newnode->m_prev = prev;
	prev->m_next = newnode;
	cur->m_prev = newnode;

	return iterator(newnode);		//返回一個(gè)用當(dāng)前的插入的元素的結(jié)點(diǎn)構(gòu)建的匿名對(duì)象的迭代器
}

void insert(iterator pos, size_t n, const T& val)	//插入n個(gè)val
{
	assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
	while (n--)
	{
		node* newnode = new node(val);

		node* cur = pos.m_pnode;
		node* prev = cur->m_prev;

		newnode->m_prev = prev;
		prev->m_next = newnode;
		newnode->m_next = cur;
		cur->m_prev = newnode;
	}
}

void insert(iterator pos, int n, const T& val)	//插入n個(gè)val
{
	assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
	assert(n > 0);
	while (n--)
	{
		node* newnode = new node(val);

		node* cur = pos.m_pnode;
		node* prev = cur->m_prev;

		newnode->m_prev = prev;
		prev->m_next = newnode;
		newnode->m_next = cur;
		cur->m_prev = newnode;
	}
}

void insert(iterator pos, long n, const T& val)	//插入n個(gè)val
{
	assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
	assert(n > 0);
	while (n--)
	{
		node* newnode = new node(val);

		node* cur = pos.m_pnode;
		node* prev = cur->m_prev;

		newnode->m_prev = prev;
		prev->m_next = newnode;
		newnode->m_next = cur;
		cur->m_prev = newnode;
	}
}

template <class InputIterator>
void insert(iterator pos, InputIterator first, InputIterator last)	//區(qū)間插入
{
	assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
	while (first != last)
	{
		node* newnode = new node(*first);

		node* cur = pos.m_pnode;
		node* prev = cur->m_prev;

		newnode->m_prev = prev;
		prev->m_next = newnode;
		newnode->m_next = cur;
		cur->m_prev = newnode;
		++first;
	}
}

//刪除指定位置的元素，返回下一個(gè)元素的迭代器，但要注意的是：
//如果刪除的最后一個(gè)元素，此時(shí)返回的是頭結(jié)點(diǎn)也就是end()位置的迭代器
iterator erase(iterator pos)			
{
	assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
	assert(pos != end());				//斷言 list內(nèi)元素為空及刪除頭結(jié)點(diǎn)的情況
	
	node* next = pos.m_pnode->m_next;
	node* prev = pos.m_pnode->m_prev;

	prev->m_next = next;
	next->m_prev = prev;

	pos.m_pnode->m_next = pos.m_pnode->m_prev = nullptr;
	pos.m_pnode->m_val = T();
	delete pos.m_pnode;

	return iterator(next);		
}

iterator erase(iterator first, iterator last)		//區(qū)間刪除
{
	node* prev = first.m_pnode->m_prev;
	node* next = last.m_pnode;

	while (first != last)
	{
		node* cur = first.m_pnode;
		++first;
		cur->m_next = cur->m_prev = nullptr;
		cur->m_val = T();
		delete cur;
		cur = nullptr;
	}

	prev->m_next = next;
	next->m_prev = prev;

	return iterator(next);
}

void clear()		//清空元素，而不是把整個(gè)鏈表刪除掉
	{
		iterator it = this->begin();	

		while (it != this->end())	
		//復(fù)用我們寫(xiě)的頭刪，一個(gè)一個(gè)的刪除，當(dāng)然也可以復(fù)用尾刪pop_back()和erase()
		{
			++it;
			this->pop_front();
		}
	}

void swap(list<T>& obj)
{
	node* temp = this->m_head;
	this->m_head = obj.m_head;
	obj.m_head = temp;
}

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using  namespace std;

namespace ZJ
{
	template<class T>	
	class list_node		//結(jié)點(diǎn)
	{
	public:
		list_node(T val=T())		//構(gòu)造函數(shù)
			:m_val(val)
			,m_prev(nullptr)
			,m_next(nullptr)
		{}
	public:
		T m_val;		//值
		list_node<T>* m_prev;	//指向前一個(gè)的指針
		list_node<T>* m_next;	//指向下一個(gè)的指針

	};

	template<class T,class Ref,class Ptr>		//封裝一個(gè)node型指針，制作成迭代器類(lèi)
	class list_iterator
	{
	public:
		typedef list_node<T> node;
		typedef list_iterator<T, Ref, Ptr>myself;
		list_iterator(node* pnode)
			:m_pnode(pnode)
		{}

		Ref operator* ()		//重載  *
		{
			return this->m_pnode->m_val;
		}

		Ptr operator->()		//重載 ->
		{
			return &this->m_pnode->m_val;
		}

		bool operator!=(const myself&obj) const		//重載！=號(hào)
		{
			return this->m_pnode != obj.m_pnode;
		}

		bool operator==(const myself& obj) const	//重載==號(hào)
		{
			return this->m_pnode == obj.m_pnode;
		}

		myself& operator++()		//重載前置++
		{
			this->m_pnode = this->m_pnode->m_next;
			return *this;
		}

		myself operator++(int)		//重載后置++
		{
			const myself temp(*this);
			this->m_pnode = this->m_pnode->m_next;
			return temp;
		}

		myself& operator--()		//重載前置--
		{
			this->m_pnode = this->m_pnode->m_prev;
			return *this;
		}

		myself operator--(int)		//重載后置--
		{
			const myself temp(*this);
			this->m_pnode = this->m_pnode->m_prev;
			return temp;
		}

	public:
		node* m_pnode;
	};

	template<class T>
	class list
	{
	public:
		typedef list_node<T> node;		
		typedef list_iterator<T,T&,T*> iterator;		//普通迭代器
		typedef list_iterator<T,const T&,const T*> const_iterator;	//常量迭代器

	public:
		list()		//無(wú)參默認(rèn)構(gòu)造函數(shù)
		{
			this->m_head = new node(T());
			this->m_head->m_next = this->m_head;
			this->m_head->m_prev = this->m_head;
		}

		list(size_t size, const T& val=T())	//n個(gè)元素構(gòu)造函數(shù)
		{
			this->m_head = new node(T());
			this->m_head->m_next = this->m_head;
			this->m_head->m_prev = this->m_head;
			while (size--)
			{
				this->push_back(val);
			}
		}

		list(long size, const T& val = T())	//n個(gè)元素構(gòu)造函數(shù)
		{
			assert(size > 0);
			this->m_head = new node(T());
			this->m_head->m_next = this->m_head;
			this->m_head->m_prev = this->m_head;
			while (size--)
			{
				this->push_back(val);
			}
		}

		list(int size, const T& val = T())	//n個(gè)元素構(gòu)造函數(shù)
		{
			assert(size > 0);
			this->m_head = new node(T());
			this->m_head->m_next = this->m_head;
			this->m_head->m_prev = this->m_head;
			while (size--)
			{
				this->push_back(val);
			}
		}

		template <class InputIterator>
		list(InputIterator first, InputIterator last)		//區(qū)間構(gòu)造
		{
			this->m_head = new node(T());
			this->m_head->m_next = this->m_head;
			this->m_head->m_prev = this->m_head;
			while (first != last)
			{
				node* newnode = new node(*first);
				node* tail = this->m_head->m_prev;
				tail->m_next = newnode;
				newnode->m_prev = tail;
				newnode->m_next = this->m_head;
				this->m_head->m_prev = newnode;
				++first;
			}
		}
		
		list(const list<T>& obj)		//拷貝構(gòu)造函數(shù)
		{
			this->m_head = new node(T());
			this->m_head->m_next = this->m_head;
			this->m_head->m_prev = this->m_head;
			const_iterator it = obj.begin();
			while (it != obj.end())
			{
				node* newnode = new node(it.m_pnode->m_val);

				node* tail = this->m_head->m_prev;
				tail->m_next = newnode;
				newnode->m_prev = tail;
				newnode->m_next = this->m_head;
				this->m_head->m_prev = newnode;
				++it;
			}
		}

		list<T>& operator=(const list<T>& obj)		//賦值運(yùn)算符重載
		{
			if (this != &obj)
			{
				list<T>temp(obj);
				this->swap(temp);
			}
			return *this;
		}


		~list()		//析構(gòu)函數(shù)
		{
			iterator it = this->begin();

			while (it != this->end())	//復(fù)用我們寫(xiě)的頭刪，一個(gè)一個(gè)的刪除，當(dāng)然也可以復(fù)用尾刪pop_back()和erase()
			{
				++it;
				this->pop_front();
			}

			delete this->m_head;
			this->m_head = nullptr;
		}

		iterator begin()
		{
			return iterator(this->m_head->m_next);
		}

		const_iterator begin()	const
		{
			return const_iterator(this->m_head->m_next);
		}

		iterator end()
		{
			return iterator(this->m_head);
		}

		const_iterator end()	const
		{
			return const_iterator(this->m_head);
		}

		bool empty()	const		//判空
		{
			return this->begin() == this->end();	//就是begin()與end()同時(shí)指向頭結(jié)點(diǎn)時(shí)的情況
		}

		//遍歷一遍鏈表來(lái)得到元素個(gè)數(shù)，為什么使用遍歷一遍鏈表呢？
		//這是因?yàn)槲覀兪褂面湵頃r(shí)很少會(huì)去知道它的元素個(gè)數(shù)，但如果頻繁的調(diào)用該接口會(huì)造成性能的下降
		//此時(shí)我們應(yīng)該在list類(lèi)中將增加一個(gè)記錄元素個(gè)數(shù)的變量size
		//如果有元素插入就增加，刪除就減少
		size_t size()	const	//獲得元素個(gè)數(shù)
		{
			size_t size = 0;
			const_iterator it = this->begin();
			while(it!=this->end())
			{
				++it;
				++size;
			}
			return size;
		}

		T& back()
		{
			assert(!this->empty());
			return this->m_head->m_prev->m_val;
		}

		const T& back()   const
		{
			assert(!this->empty());
			return this->m_head->prev->m_val;
		}

		T& front()
		{
			assert(!this->empty());
			return  this->m_head->m_next->m_val;
		}

		const T& front() const
		{
			assert(!this->empty());
			return this->m_head->m_next->m_val;
		}

		void push_front(const T& val)	//頭插
		{
			node* newnode = new node(val);
			node*  next = this->m_head->m_next;
			newnode->m_next = next;
			this->m_head->m_next = newnode;
			newnode->m_prev = this->m_head;
			next->m_prev = newnode;
		}

		void push_back(const T& val)	//尾插
		{
			node* tail = this->m_head->m_prev;
			node* newnode = new node(val);
			newnode->m_next = tail->m_next;
			newnode->m_prev = tail;
			tail->m_next = newnode;
			this->m_head->m_prev = newnode;
		}


		//插入元素到指定位置，返回的是插入的元素的迭代器
		iterator insert(iterator pos, const T& val)
		{
			assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
			node* newnode = new node(val);		//創(chuàng)建新結(jié)點(diǎn)

			node* cur = pos.m_pnode;		//記錄當(dāng)前結(jié)點(diǎn)的指針
			node* prev = cur->m_prev;		//記錄當(dāng)前結(jié)點(diǎn)的前一個(gè)結(jié)點(diǎn)的指針

			newnode->m_next = cur;
			newnode->m_prev = prev;
			prev->m_next = newnode;
			cur->m_prev = newnode;

			return iterator(newnode);		//返回一個(gè)用當(dāng)前的插入的元素的結(jié)點(diǎn)構(gòu)建的匿名對(duì)象的迭代器
		}

		void insert(iterator pos, size_t n, const T& val)	//插入n個(gè)val
		{
			assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
			while (n--)
			{
				node* newnode = new node(val);

				node* cur = pos.m_pnode;
				node* prev = cur->m_prev;

				newnode->m_prev = prev;
				prev->m_next = newnode;
				newnode->m_next = cur;
				cur->m_prev = newnode;
			}
		}

		void insert(iterator pos, int n, const T& val)	//插入n個(gè)val
		{
			assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
			assert(n > 0);
			while (n--)
			{
				node* newnode = new node(val);

				node* cur = pos.m_pnode;
				node* prev = cur->m_prev;

				newnode->m_prev = prev;
				prev->m_next = newnode;
				newnode->m_next = cur;
				cur->m_prev = newnode;
			}
		}

		void insert(iterator pos, long n, const T& val)	//插入n個(gè)val
		{
			assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
			assert(n > 0);
			while (n--)
			{
				node* newnode = new node(val);

				node* cur = pos.m_pnode;
				node* prev = cur->m_prev;

				newnode->m_prev = prev;
				prev->m_next = newnode;
				newnode->m_next = cur;
				cur->m_prev = newnode;
			}
		}

		template <class InputIterator>
		void insert(iterator pos, InputIterator first, InputIterator last)	//區(qū)間插入
		{
			assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
			while (first != last)
			{
				node* newnode = new node(*first);

				node* cur = pos.m_pnode;
				node* prev = cur->m_prev;

				newnode->m_prev = prev;
				prev->m_next = newnode;
				newnode->m_next = cur;
				cur->m_prev = newnode;
				++first;
			}
		}

		void pop_front()	//頭刪
		{
			assert(!empty());	//斷言 如果list已經(jīng)為空，則刪除不了
			node* delnode = this->m_head->m_next;
			node* next = delnode->m_next;
			this->m_head->m_next = next;
			next->m_prev = this->m_head;
			delnode->m_next = delnode->m_prev = nullptr;
			delnode->m_val = T();
			delete delnode;
		}

		void pop_back()		//尾刪
		{
			assert(!empty());	//斷言 如果list已經(jīng)為空，則刪除不了
			node* tail = this->m_head->m_prev;
			node* prev = tail->m_prev;
			this->m_head->m_prev = prev;
			prev->m_next = this->m_head;
			tail->m_next = tail->m_prev = nullptr;
			tail->m_val = T();
			delete tail;
		}


		//刪除指定位置的元素，返回下一個(gè)元素的迭代器，但要注意的是：
		//如果刪除的最后一個(gè)元素，此時(shí)返回的是頭結(jié)點(diǎn)也就是end()位置的迭代器
		iterator erase(iterator pos)			
		{
			assert(pos.m_pnode != nullptr);		//斷言 迭代器是否為空指針錯(cuò)誤
			assert(pos != end());				//斷言 list內(nèi)元素為空及刪除頭結(jié)點(diǎn)的情況
			
			node* next = pos.m_pnode->m_next;
			node* prev = pos.m_pnode->m_prev;

			prev->m_next = next;
			next->m_prev = prev;

			pos.m_pnode->m_next = pos.m_pnode->m_prev = nullptr;
			pos.m_pnode->m_val = T();
			delete pos.m_pnode;

			return iterator(next);		
		}

		iterator erase(iterator first, iterator last)		//區(qū)間刪除
		{
			node* prev = first.m_pnode->m_prev;
			node* next = last.m_pnode;

			while (first != last)
			{
				node* cur = first.m_pnode;
				++first;
				cur->m_next = cur->m_prev = nullptr;
				cur->m_val = T();
				delete cur;
				cur = nullptr;
			}

			prev->m_next = next;
			next->m_prev = prev;

			return iterator(next);
		}

		void clear()		//清空元素，而不是把整個(gè)鏈表刪除掉
		{
			iterator it = this->begin();	

			while (it != this->end())	//復(fù)用我們寫(xiě)的頭刪，一個(gè)一個(gè)的刪除，當(dāng)然也可以復(fù)用尾刪pop_back()和erase()
			{
				++it;
				this->pop_front();
			}
		}

		void swap(list<T>& obj)
		{
			node* temp = this->m_head;
			this->m_head = obj.m_head;
			obj.m_head = temp;
		}
	private:
		node* m_head;		//頭指針
	};
}