C++之list的使用与模拟实现过程

#include<list>
#include<vector>
using namespace std;

int main()
{
	list<int> l1;       //不初始化

	list<int> l2(5, 10);//用5个10来初始化

	list<int> l3(l2);	//拷贝构造

	vector<int> v = { 1,2,3,4,5,6 };
	list<int> l4(v.begin(), v.end());//用迭代器区间来初始化

	return 0;
}

void Test1()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, array + sizeof(array) / sizeof(array[0]));
	auto it = l.begin();
	while (it != l.end())
	{
		// erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋值
		l.erase(it);
		++it;
	}
}
// 改正
void Test()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, array + sizeof(array) / sizeof(array[0]));
	auto it = l.begin();
	while (it != l.end())
	{
		l.erase(it++); // it = l.erase(it);
	}
}

//节点
template<class T>
struct list_node
{
	T _data;
	list_node* _next;
	list_node* _prev;

	list_node(T data = T())
	{
		_data = data;
		_next = _prev = this;
	}
};

//迭代器
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 = nullptr)
		:_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;
	}
	//后置
	Self& operator++(int)
	{
		_node = _node->_next;
		return _node->prev;
	}
	Self& operator--(int)
	{
		_node = _node->_prev;
		return _node->_next;
	}
	bool operator!=(const Self& it)const
	{
		return _node != it._node;
	}
	bool operator==(const Self& it)const
	{
		return _node == it._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;

	// List的构造
	void init_head()
	{
		_head = new Node;
	}
	list()
	{
		init_head();
	}
	list(int n, const T& value = T())
	{
		init_head();
		while (n--)
		{
			push_back(value);
		}
	}
	template <class Iterator>
	list(Iterator first, Iterator last)
	{
		init_head();
		while (first != last)
		{
			push_back(*first);
			++first;
		}
	}
	list(list<T>& ls)
		:_head(new Node)
	{
		for (auto i : ls)
		{
			push_back(i);
		}
	}
	//赋值重载
	/*list<T>& operator=(list<T>& ls)
	{
		for (iterator it = begin();it!=end();)
		{
			it = erase(it);
		}
		for (auto i : ls)
		{
			push_back(i);
		}
		return *this;
	}*/
	list<T>& operator=(list<T> ls)
	{
		swap(ls);
		return *this;
	}
	~list()
	{
		clear();
		delete _head;
		_head = nullptr;
	}


	// List Iterator
	iterator begin()
	{
		return iterator(_head->_next);
	}
	iterator end()
	{
		return iterator(_head);
	}
	const_iterator begin()const
	{
		return const_iterator(_head->_next);
	}
	const_iterator end()const
	{
		//return iterator(_head);
		return const_iterator(_head);
	}

	// List Capacity
	size_t size()const
	{
		size_t cnt = 0;
		for (auto i : *this)
		{
			++cnt;
		}
		return cnt;
	}
	bool empty()const
	{
		return _head->_next == _head;
	}
	// List Access
	T& front()
	{
		return _head->_next->_data;
	}
	const T& front()const
	{
		return _head->_next->_data;
	}
	T& back()
	{
		return _head->_prev->_data;
	}
	const T& back()const
	{
		return _head->_prev->_data;![请添加图片描述](https://i-blog.csdnimg.cn/direct/73edd14ebffb4fb8a9a82434243b58ca.jpg)

	}
	// List Modify
	void push_back(T data)
	{
		/*Node* cur = new Node(data);
		cur->_next = _head;
		cur->_prev = _head->_prev;
		_head->_prev = cur;
		cur->_prev->_next = cur;*/
		insert(end(), data);
	}
	void pop_back()
	{
		erase(--end());
	}
	void push_front(const T& val)
	{
		insert(begin(), val);
	}
	void pop_front()
	{
		erase(begin());
	}
	// 在pos位置前插入值为val的节点
	iterator insert(iterator pos, const T& val)
	{
		Node* newnode = new Node(val);
		newnode->_next = pos._node;
		newnode->_prev = pos._node->_prev;
		newnode->_next->_prev = newnode;
		newnode->_prev->_next = newnode;
		return newnode;
	}
	// 删除pos位置的节点，返回该节点的下一个位置
	iterator erase(iterator pos)
	{
		//assert(end());
		pos._node->_prev->_next = pos._node->_next;
		pos._node->_next->_prev = pos._node->_prev;
		iterator it = pos._node->_next;

		delete pos._node;
		return it;
	}
	void clear()
	{
		for (iterator it = begin(); it != end();)
		{
			it = erase(it);
		}
	}
	void swap(list<T>& ls)
	{
		std::swap(this->_head, ls._head);
	}


private:
	Node* _head;
};