list的模拟实现

cpp	template<class T>
	struct Node
	{
		Node* prve;
		Node* next;
		T data;

		Node(const T &x=T())
			:prve(nullptr)
			,next(nullptr)
			,data(x)
		{}
	};
	template<class T>
	class list
	{
		typedef Node<T> Node;
		Node* head;
	}

cpp		void empty_init()
		{
			head = new Node;
			head->prve = head;
			head->next = head;
		}
		list()
		{
			empty_init();
		}

		template<class Iterator>
		list(Iterator first, Iterator last)
		{
			empty_init();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
				list(int n, const T& x = T())
		{
			empty_init();
			while (n--)
			{
				push_back(x);
			}
		}

cpp		list(const list<T>& it)
		{
			empty_init();
			list<T> temp;
			const_iterator cur = it.begin();
			while (cur != it.end())
			{
				temp.push_back(*cur);
				++cur;
			}
			swap(temp);
		}

cpp		~list()
		{
			clear();
			delete head;
			head = nullptr;
		}

cpp	template<class T,class ref,class ptr>
	struct __iterator
	{
		typedef Node<T> Node;
		typedef __iterator<T, ref, ptr> Self;
		Node* node;
		
		__iterator(Node* cur)
			:node(cur)
		{}

		Self operator++()
		{
			node = node->next;
			return *this;
		}
		Self operator++(int)
		{
			Node* temp = node;
			node = node->next;
			return Self(temp);
		}
		Self operator--()
		{
			node = node->prve;
			return *this;
		}
		Self operator--(int)
		{
			Node* temp = node;
			node = node->prve;
			return Self(temp);
		}
		ref operator*()
		{
			return node->data;
		}
		ptr operator->()
		{
			return &(node->data);
		}
		bool operator!=(Self x)
		{
			return node != x.node;
		}
	};

cpp	iterator insert(iterator pos, const T& x)
	{
		Node* newnode = new Node(x);
		Node* cur = pos.node;
		Node* pcur = cur->prve;
		pcur->next = newnode;
		newnode->prve = pcur;
		newnode->next = cur;
		cur->prve = newnode;
		return iterator(newnode);
	}

cpp		iterator erase(iterator pos)
		{
			Node* cur = pos.node;
			Node* pcur = cur->prve;
			Node* _next = cur->next;

			pcur->next = cur->next;
			cur->next->prve = pcur;
			delete cur;
			return iterator(_next);
		}

cpp		T& back()
		{
			return head->prve->data;
		}

cpp		T& front()
		{
			return head->next->data;
		}

cpp		bool empty()
		{
			return head->next == head;
		}