【C++】STL——list

用户11290673

发布于 2024-09-25 13:14:47

320

发布于 2024-09-25 13:14:47

文章被收录于专栏：学习

前言本篇博客我们接着来理解一个STL库里的list链表的结构，根据前面数据结构的铺垫，理解这个结构相对比较容易。我们来一起看看吧 💓 个人主页：小张同学zkf ⏩ 文章专栏：C++ 若有问题评论区见📝 🎉欢迎大家点赞👍收藏⭐文章

1.list介绍

文档：list

2.list使用

2.1list的构造

2.2list capacity

2.3list element access

2.4list modifiers

3.list迭代器

此处大家可将迭代器暂时理解成类似于指针， 迭代器失效即迭代器所指向的节点的无 效，即该节点被删除了 。因为 list 的底层结构为带头结点的双向循环链表 ，因此在 list 中进行插入 时是不会导致 list 的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭 代器，其他迭代器不会受到影响 。

void TestListIterator1 () { 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 TestListIterator () { 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); } }

4.list模拟实现

#include<iostream>
#include<assert.h>
using namespace std;
namespace zkf
{
	template<class T>
	struct list_node
	{
		T _date;
		list_node<T>* _next;
		list_node<T>* _prev;
		list_node(const	T& s=T())
			:_date(s)
			, _next(nullptr)
			, _prev(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->_date;
		}
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		self& operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
		self& operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		bool operator!=(const self& s)
		{
			return _node!= s._node;
		}
		ptr operator->()
		{
			return &_node->_date;
		}
	};
	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->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
		list()
		{
			empty_init();
		}
		list(const list<T>& s)
		{
			empty_init();
			for (auto& it : s)
			{
				push_back(it);
			}
		}
		void swap(list<T>& s)
		{
			std::swap(_head, s._head);
			std::swap(_size, s._size);
		}
		list<T>& operator=(list<T> s)
		{
			swap(s);
			return *this;
		}
		iterator insert(iterator it, const T& s)
		{
			node* newnode = new node(s);
			node* tail=(it._node)->_prev;
			newnode->_prev = tail;
			newnode->_next = it._node;
			tail->_next = newnode;
			(it._node)->_prev = newnode;
			++_size;
			return newnode;
		}
		iterator erase(iterator it)
		{
			assert(it != end());
			node* prev = (it._node)->_prev;
			node* next = (it._node)->_next;
			prev->_next = next;
			next->_prev = prev;
			delete it._node;
			--_size;
			return next;
		}
		void push_back(const T& s)
		{
			insert(end(), s);
		}
		void push_front(const T& s)
		{
			insert(begin(), s);
		}
		void pop_back()
		{
			erase(--end());
		}
		void pop_front()
		{
			erase(begin());
		}
		size_t size()const
		{
			return _size;
		}
		bool empty()const
		{
			return _size == 0;
		}
		iterator begin()
		{
			
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin()const
		{

			return _head->_next;
		}
		const_iterator end()const
		{
			return _head;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it=erase(it);
			}
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
	private:
		node* _head; 
		size_t _size;
	};