【C++篇】list模拟实现

实现接口：

1. list的无参构造、n个val构造、拷贝构造

2. operator=重载

3. 实现迭代器

4. push_back()

5. push_front()

6. erase()

7. insert()

8. 头尾删

#pragma once
#include
#include
using namespace std;

namespace liu
{
	//定义list节点
	template
	struct list_node
	{
		T  _data;
		list_node* _prev;
		list_node* _next;

		list_node(const T& x=T())
			:_data(x)
			,_prev(nullptr)
			,_next(nullptr)
		{}
	};

	template
	struct list_iterator
	{
		typedef list_nodeNode;
		typedef list_iteratorSelf;
		Node* _node;

		list_iterator(Node* node)
			:_node(node)
		{}

		Ref operator*()
		{
			return _node->_data;
		}
		
		Ptr operator->()
		{
			return &_node->_data;
		}

		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

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

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



	template
	class list
	{
		//链表存储链表节点
		typedef list_node Node;
	public:
		//实现接口
		typedef list_iteratoriterator;
		typedef list_iterator const_iterator;
		void empty_init()
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;
		}

		list()//无参构造
		{
			empty_init();
		}

		list(size_t n,const T& val=T())//n个val
		{
			empty_init();
			for (int i=0;i& i1)
		{
			empty_init();
			for(auto& x:i1)
			{
				push_back(x);
			}
		}

		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			auto it = begin();
			while (it!=end())
			{
				it=erase(it);
			}
		}

		iterator begin()
		{
			return iterator(_head->_next);
		}

		const_iterator begin()const
		{
			return const_iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		const_iterator end()const
		{
			return const_iterator(_head);
		}


		iterator insert(iterator pos,const T&val)
		{
			

			Node* new_node = new Node(val);
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			prev->_next = new_node;
			new_node->_prev = prev;

			cur->_prev = new_node;
			new_node->_next = cur;

			return iterator(new_node);
		}

		iterator erase(iterator pos)
		{
			assert(pos!=end());

			Node* del = pos._node;
			Node* prev = del->_prev;
			Node* next = del->_next;

			prev->_next = next;
			next->_prev = prev;
			delete del;

			return iterator(next);

		}

		void pop_front()
		{
			erase(begin());
		}


		void pop_back()
		{
			erase(--end());
		}

		void swap(list& i1)
		{
			std::swap(_head,i1._head);
		}

		

		list& operator=(list il)
		{
			swap(il);
			return *this;
		}

		void push_back(const T& x)
		{
			/*Node* new_node = new Node(x);
			Node* tail = _head->_prev;

			tail->_next = new_node;
			new_node->_prev = tail;

			new_node->_next = _head;
			_head->_prev = new_node;*/
			insert(end(),x);
		}

		void push_front(const T& x)
		{
			/*Node* new_node = new Node(x);
			Node* prev = _head->_next;

			_head->_next = new_node;
			new_node->_prev = _head;

			prev->_prev = new_node;
			new_node->_next = prev;*/
			insert(begin(), x);
		}
	private:
		Node* _head;//双端链表，哨兵位
	};

	template
	void swap(T&a,T& b)
	{
		T c(a);
		a = b;
		b = c;
	}
	template
	void swap(list& a, list& b)
	{
		a.swap(b);
	}
	

	void test1()
	{
		/*liu::listi1;
		i1.push_back(1);
		i1.push_back(2);
		i1.push_back(3);
		i1.push_back(4);

		i1.push_front(5);
		i1.push_front(6);
		i1.push_front(7);

		liu::list::iterator it1 = i1.begin();
		while (it1!=i1.end())
		{
			cout << *it1 << " ";
			++it1;
		}
		cout << endl;
		liu::list::iterator it2 = i1.begin();
		it2=i1.erase(it2);
		while (it2 != i1.end())
		{
			cout << *it2 << " ";
			++it2;
		}*/

		liu::listi1(10,1);
		liu::listi2(10,2);
		liu::swap(i1, i2);

		for (auto x : i2)
		{
			cout << x << " ";
		}
		cout << endl;

		for (auto x : i1)
		{
			cout << x << " ";
		}
		cout << endl;
	}
}