【C++篇】list模拟实现

实现接口：

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

2. operator=重载

3. 实现迭代器

4. push_back()

5. push_front()

6. erase()

7. insert()

8. 头尾删

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

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

    	list_node(const T& x=T())
    		:_data(x)
    		,_prev(nullptr)
    		,_next(nullptr)
    	{}
    };
   
    template<class T,class Ref,class Ptr>
    struct list_iterator
    {
    	typedef list_node<T>Node;
    	typedef list_iterator<T, Ref, Ptr>Self;
    	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 T>
    class list
    {
    	//链表存储链表节点
    	typedef list_node<T> Node;
    public:
    	//实现接口
    	typedef list_iterator<T, T&,  T*>iterator;
    	typedef list_iterator<T, const T&, const T*> 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<n;i++)
    		{
    			push_back(val);
    		}
    	}
   
    	list(const list<T>& 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<T>& i1)
    	{
    		std::swap(_head,i1._head);
    	}
   
    	
   
    	list<T>& operator=(list<T> 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<class T>
    void swap(T&a,T& b)
    {
    	T c(a);
    	a = b;
    	b = c;
    }
    template<class T>
    void swap(list<T>& a, list<T>& b)
    {
    	a.swap(b);
    }
    
   
    void test1()
    {
    	/*liu::list<int>i1;
    	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<int>::iterator it1 = i1.begin();
    	while (it1!=i1.end())
    	{
    		cout << *it1 << " ";
    		++it1;
    	}
    	cout << endl;
    	liu::list<int>::iterator it2 = i1.begin();
    	it2=i1.erase(it2);
    	while (it2 != i1.end())
    	{
    		cout << *it2 << " ";
    		++it2;
    	}*/
   
    	liu::list<int>i1(10,1);
    	liu::list<int>i2(10,2);
    	liu::swap(i1, i2);
   
    	for (auto x : i2)
    	{
    		cout << x << " ";
    	}
    	cout << endl;
   
    	for (auto x : i1)
    	{
    		cout << x << " ";
    	}
    	cout << endl;
    }

   }