STL容器 -- list的模拟实现(配详细注释)

目录

  • 一、list容器是什么?
  • 二、list的模拟实现
    • 2.1 节点ListNode
    • 2.2 成员变量
    • 2.3 四大默认成员函数
      • 2.3.1 构造函数
      • 2.3.2 拷贝构造函数
      • 2.3.3 赋值重载函数
      • 2.3.4 析构函数
    • 2.4 迭代器(重点内容)
    • 2.5 insert函数
    • 2.6 erase函数
    • 2.7 尾插尾删、头插头删函数
  • 三、list模拟实现代码汇总

一、list容器是什么?

C++ STL(Standard Template Library,标准模板库)提供了一组通用的模板类和函数,用于实现常用的数据结构和算法。其中之一是 std::list,它实现了一个双向链表。

std::list 是一个容器,用于存储一系列的值。与数组和向量等连续存储的容器不同,std::list 使用链表作为底层数据结构。每个节点都包含一个值,并且有指向前一个节点和后一个节点的指针,通过这些指针将节点连接起来。

由于使用链表作为底层结构,std::list 具有以下特点:

1、插入和删除效率高:在链表中插入和删除节点的操作非常高效,时间复杂度为O(1)。因为它不涉及元素的移动和内存的重新分配。

2、不支持随机访问:由于链表中的元素不是连续存储的,因此不能像数组或向量一样使用下标来随机访问元素。需要从链表的起始点或结束点沿着指针移动来访问元素,这会导致访问效率较低。

3、不占用连续内存:相比连续存储容器,链表不需要一块连续的内存空间,这使得它可以灵活地处理内存的分配和释放。

std::list 提供了一系列成员函数用于插入、删除和访问链表中的元素,如 push_back()、push_front()、pop_back()、pop_front()、insert()、erase() 等。此外,它还支持迭代器(iterator)用于遍历链表和访问元素。

二、list的模拟实现

2.1 节点ListNode

list存放的不仅仅是这个value本身,而是一个用类来封装value的节点,因为这是双向带头循环链表,所以节点里还需要有next和prev指针,方便查找该节点的下一个和上一个节点。节点的value的类型是不确定的,所以这是一个类模板。

	//类模板的模板参数
	template <class T>
	struct ListNode
	{
		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _val;

		//需要提供构造函数,在新增节点时可以直接使用new,得到新结点
		//这里的缺省值不能简单地写成0,因为T是不确定的类型,0只能代表
		//整形,假如T是其它类型的话就不能是0了,所以我们要写成T类型的
		//匿名对象,这样编译器就会自动地根据T的类型构造匿名对象作为
		//缺省值了,如果T是自定义类型,编译器会自动调用默认构造函数
		//构造匿名对象的,内置类型也有构造函数,整形默认构造成0
		ListNode(const T& x = T())
			:_prev(nullptr)
			, _next(nullptr)
			, _val(x)
		{}

	};

2.2 成员变量

对于list,最重要的成员变量就是需要一个哨兵位的头节点_head,这个_head节点不包含有效数据,仅仅作为链表的头,方便后续的插入删除等操作。其次,可以加一个_size成员,记录一个链表的长度。

	private:
		Node* _head;
		size_t _size;

2.3 四大默认成员函数

2.3.1 构造函数

构造函数的目的是完成对成员变量的初始化工作,显然这里构造函数就是创建一个哨兵位的头节点即可。

		void emptyInit()
		{
			_head = new Node;

			//双向带头循环链表,没有元素的时候哨兵位的头节点
			//的_next和_prev都是指向自己本身的
			_head->_prev = _head;
			_head->_next = _head;
			_size = 0;
		}

		//构造函数
		list()
		{
		    //初始化
			emptyInit();
		}

2.3.2 拷贝构造函数

依旧存在深浅拷贝问题,为了避免链表中的节点被释放两次,依然需要深拷贝,即创建一个新的哨兵位的头节点,再把被拷贝的链表的每个节点都new出来,连接到这个新的哨兵位的头节点上去。

		//拷贝构造
		list(const list<T>& lt)
		{
			emptyInit();

			//const_iterator it = lt.begin();
			//while (it != lt.end())
			//{
			//	push_back(*it);
			//	++it;
			//}

			for (const auto& e : lt)
			{
				//把lt链表的所有节点都尾插到新的链表中即可
				push_back(e);
			}
		}

2.3.3 赋值重载函数

		void Swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		//赋值重载(现代写法)

		//利用传参的特性,传参时会调用拷贝构造函数构造一个临时的list,而这个
		//list的内容就是新的链表所需要的,所以直接交换两者的成员函数即可,即
		//交换哨兵位的头节点_head和_size即可
		list<T>& operator=(list<T> lt)
		{
			Swap(lt);

			return *this;
		}

2.3.4 析构函数

析构函数是完成对链表中的节点的清理工作,我们需要把链表的节点一个一个地释放,最后再释放哨兵位的头节点_head。

		void clear()
		{
			//需要一个一个地删除释放链表中的节点
			iterator it = begin();
			while (it != end())
			{
			    //erase之后迭代器会失效,必须接受返回值更新it才能继续删
				it = erase(it);
			}
			_size = 0;
		}

		~list()
		{
			//先清理释放链表中的有效节点
			clear();
			//再释放哨兵位的头节点_head
			delete _head;
			_head = nullptr;
		}

2.4 迭代器(重点内容)


list容器的迭代器和前面的string和vector就不一样了,为什么呢?通过string和vector的性质可以发现,string和vector的底层都是用数组实现的,数组是具有连续的空间的,但是list就不同了,list底层是一个一个的节点连接起来的,并不是连续的空间,迭代器的要求是迭代器++能够指向下一个元素,迭代器“*”解引用能够找到这个迭代器指向的对象。

对于string和vector来说,原生指针就能做到++指向下一个元素,解引用能够得到指向的这个对象,但是对于list来说,++不能使迭代器指向下一个元素,因为空间不连续,解引用也不能得到我们想要的这个value,得到的是这个节点对象。所以对于list我们就不能直接用原生指针作为迭代器了。

那么我们要怎么设计这个迭代器呢?list之所以不能用原生指针直接作为迭代器,是因为链表的指针++不能找到下一个节点的地址,解引用不能得到这个value值,那么对于链表我们是怎么查找下一个节点的呢?那不就是_node=_node->_next吗?也就是说我们要使迭代器++的行为不再是单纯的指针++,而是使_node指针指向下一个,但是内置类型的++的行为是固定的啊,即对于内置类型的++操作的行为我们是不能改变的,这个时候C++中的运算符重载的意义就凸显了,内置类型的运算符的行为我们不能修改,但是自定义类型的运算符的行为我们是可以自定义的呀,你想怎么设计就怎么设计。

由此可知,我们要想使list的迭代器的++或者解引用等操作跟sting和vector一样,就需要用一个自定义的类封装指针,利用运算符重载控制迭代器的++,解引用等行为,设计出与string,vector一样的迭代器。所以在上层看似一样的迭代器,底层确实完全不一样的东西,而正是底层复杂的封装,才使得上层应用的时候都是一样的规则,所以看东西可不能只看表面哦!以下是迭代器的封装。

	//T是T   Ref是T&/const T&   Ptr是T*/const T*
	//为什么要传三个模板参数,主要是为了同一份代码实现iterator和const_iterator
	//const_iterator是迭代器指向的内容不能修改,所以返回值需要是const版本的,
	//当Ref是const T&时,*返回的是const T&,是不能修改的,当Ptr是const T*时,
	//->返回值是const T*,指向的内容也是不能被修改的;符合const版本的迭代器。
	//如果Ref是T&,Ptr是T*,就是普通版本的迭代器,传三个参数的目的是让编译器
	//根据模板参数的类型实例化出普通迭代器和const迭代器
	template <class T,class Ref, class Ptr>
	struct __list_iterator
	{
		typedef ListNode<T> Node;
		typedef __list_iterator<T,Ref,Ptr> self;
		//list的迭代器只是对Node*指针进行了封装,形成了一个类,这样就可以
		//通过运算符重载来控制迭代器++,解引用等行为
		Node* _node;

	public:
		//迭代器的构造函数的参数只需要传一个指针即可
		__list_iterator(Node* ptr)
			:_node(ptr)
		{}

		//重载前置++,按照++的要求,迭代器++就指向下一个节点,所以
		//_node=_node->_next就指向了下一个节点
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		//重载后置++,为了与前置++区分,需要加一个参数做占位符
		//跟前置++一样的道理,只不过后置++的返回值是++前的结果
		//所以需要先保存当前迭代器,再让迭代器往后走
		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}

		//重置前置--,--是找到前一个迭代器,所以_node=_node->_prev
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		//与后置++原理类似,需要占位符做区分,并且需要先保存当前位置的迭代器
		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

		//*解引用目的是拿到节点中的value值,所以以引用的方式返回_node->_val即可
		//对比原来的原生指针解引用拿到_node结构体,这里重载了*就能直接拿到value值
		//达到了和string和vector一样的效果
		Ref operator*()
		{
			return _node->_val;
		}

		//重载->,因为value也可能是一个自定义类型,箭头返回的是节点中value的地址,
		//可以通过->访问这个自定义类型的里的成员
		Ptr operator->()
		{
			return &_node->_val;
		}

		//必须带上const,因为调用operator!=的迭代器对象的参数是lt.end(),lt.end()
		//本身是通过传值返回的,是iterator的一份临时拷贝,具有常性,所以必须用const接收
		//比较两个迭代器是否相等,本质是比较迭代器里的_node指针是否相等
		bool operator!=(const self& it)
		{
			return _node != it._node;
		}

		bool operator==(const self& it)
		{
			return _node == it._node;
		}

	};

所以要在list类中实现迭代器就变得非常简单了。

		//双向带头循环链表的begin是哨兵位的头节点的_next
		iterator begin()
		{
			//return iterator(_head->_next);

			//单参数构造函数的类支持隐式类型的转换
			//可以直接这样写,编译器会自动调用iterator
			//的构造函数构造匿名对象返回
			return _head->_next;
		}

		//因为这是双向带头循环链表,而end又是指最后一个元素的下一个位置,
		//所以就是_head的位置
		iterator end()
		{
			return _head;
		}

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

		const_iterator end() const
		{
			return _head;
		}

2.5 insert函数

		iterator insert(iterator pos, const T& x)
		{
			//先创建一个新结点
			Node* newNode = new Node(x);
			//先把迭代器转换成节点的指针Node*,方便操作
			Node* cur = pos._node;
			//记录前一个节点
			Node* prev = cur->_prev;

			//更改连接关系,这个就easy了
			prev->_next = newNode;
			newNode->_prev = prev;
			newNode->_next = cur;
			cur->_prev = newNode;

			//最后记得更新_size
			++_size;

			//同样存在隐式类型的转换
			return newNode;
		}

2.6 erase函数

		iterator erase(iterator pos)
		{
			//断言,不能删除哨兵位的头节点
			assert(pos != end());

			//先把迭代器转换成Node*的指针,方便更改连接关系
			Node* cur = pos._node;

			//保存下一个节点
			Node* next = cur->_next;

			//保存前一个节点
			Node* prev = cur->_prev;

			//前一个节点与后一个节点连接起来即可
			prev->_next = next;
			next->_prev = prev;

			//释放要删除的节点
			delete cur;
			cur = nullptr;

			//最后记得--_size
			--_size;

			//同样存在隐式类型的转换
			return next;
		}

2.7 尾插尾删、头插头删函数

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

			//复用insert即可
			insert(end(), x);
			
		}

		void pop_back()
		{
			//assert(_head->_prev != _head);

			//Node* tail = _head->_prev;
			//Node* tailPrev = tail->_prev;
			//tailPrev->_next = _head;
			//_head->_prev = tailPrev;
			//delete tail;
			//tail = nullptr;

			//复用erase即可
			erase(--end());
		}

		void push_front(const T& x)
		{
			//复用
			insert(begin(), x);
		}

		void pop_front()
		{
			//复用
			erase(begin());
		}

三、list模拟实现代码汇总

#pragma once

#include 
using namespace std;
#include 

namespace kb
{
	//类模板的模板参数
	template <class T>
	struct ListNode
	{
		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _val;

		//需要提供构造函数,在新增节点时可以直接使用new,得到新结点
		//这里的缺省值不能简单地写成0,因为T是不确定的类型,0只能代表
		//整形,假如T是其它类型的话就不能是0了,所以我们要写成T类型的
		//匿名对象,这样编译器就会自动地根据T的类型构造匿名对象作为
		//缺省值了,如果T是自定义类型,编译器会自动调用默认构造函数
		//构造匿名对象的,内置类型也有构造函数,整形默认构造成0
		ListNode(const T& x = T())
			:_prev(nullptr)
			, _next(nullptr)
			, _val(x)
		{}

	};


	//T是T   Ref是T&/const T&   Ptr是T*/const T*
	//为什么要传三个模板参数,主要是为了同一份代码实现iterator和const_iterator
	//const_iterator是迭代器指向的内容不能修改,所以返回值需要是const版本的,
	//当Ref是const T&时,*返回的是const T&,是不能修改的,当Ptr是const T*时,
	//->返回值是const T*,指向的内容也是不能被修改的;符合const版本的迭代器。
	//如果Ref是T&,Ptr是T*,就是普通版本的迭代器,传三个参数的目的是让编译器
	//根据模板参数的类型实例化出普通迭代器和const迭代器
	template <class T,class Ref, class Ptr>
	struct __list_iterator
	{
		typedef ListNode<T> Node;
		typedef __list_iterator<T,Ref,Ptr> self;
		//list的迭代器只是对Node*指针进行了封装,形成了一个类,这样就可以
		//通过运算符重载来控制迭代器++,解引用等行为
		Node* _node;

	public:
		//迭代器的构造函数的参数只需要传一个指针即可
		__list_iterator(Node* ptr)
			:_node(ptr)
		{}

		//重载前置++,按照++的要求,迭代器++就指向下一个节点,所以
		//_node=_node->_next就指向了下一个节点
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		//重载后置++,为了与前置++区分,需要加一个参数做占位符
		//跟前置++一样的道理,只不过后置++的返回值是++前的结果
		//所以需要先保存当前迭代器,再让迭代器往后走
		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}

		//重置前置--,--是找到前一个迭代器,所以_node=_node->_prev
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		//与后置++原理类似,需要占位符做区分,并且需要先保存当前位置的迭代器
		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

		//*解引用目的是拿到节点中的value值,所以以引用的方式返回_node->_val即可
		//对比原来的原生指针解引用拿到_node结构体,这里重载了*就能直接拿到value值
		//达到了和string和vector一样的效果
		Ref operator*()
		{
			return _node->_val;
		}

		//重载->,因为value也可能是一个自定义类型,箭头返回的是节点中value的地址,
		//可以通过->访问这个自定义类型的里的成员
		Ptr operator->()
		{
			return &_node->_val;
		}

		//必须带上const,因为调用operator!=的迭代器对象的参数是lt.end(),lt.end()
		//本身是通过传值返回的,是iterator的一份临时拷贝,具有常性,所以必须用const接收
		//比较两个迭代器是否相等,本质是比较迭代器里的_node指针是否相等
		bool operator!=(const self& it)
		{
			return _node != it._node;
		}

		bool operator==(const self& it)
		{
			return _node == it._node;
		}

	};

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef __list_iterator<T,T&,T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;

		void emptyInit()
		{
			_head = new Node;

			//双向带头循环链表,没有元素的时候哨兵位的头节点
			//的_next和_prev都是指向自己本身的
			_head->_prev = _head;
			_head->_next = _head;
			_size = 0;
		}

		//构造函数
		list()
		{
			//初始化
			emptyInit();
		}

		//拷贝构造
		list(const list<T>& lt)
		{
			emptyInit();

			//const_iterator it = lt.begin();
			//while (it != lt.end())
			//{
			//	push_back(*it);
			//	++it;
			//}

			for (const auto& e : lt)
			{
				//把lt链表的所有节点都尾插到新的链表中即可
				push_back(e);
			}
		}

		void Swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		//赋值重载(现代写法)

		//利用传参的特性,传参时会调用拷贝构造函数构造一个临时的list,而这个
		//list的内容就是新的链表所需要的,所以直接交换两者的成员函数即可,即
		//交换哨兵位的头节点_head和_size即可
		list<T>& operator=(list<T> lt)
		{
			Swap(lt);

			return *this;
		}

		void clear()
		{
			//需要一个一个地删除释放链表中的节点
			iterator it = begin();
			while (it != end())
			{
				//erase之后迭代器会失效,必须接受返回值更新it才能继续删
				it = erase(it);
			}
			_size = 0;
		}

		~list()
		{
			//先清理释放链表中的有效节点
			clear();
			//再释放哨兵位的头节点_head
			delete _head;
			_head = nullptr;
		}

		//双向带头循环链表的begin是哨兵位的头节点的_next
		iterator begin()
		{
			//return iterator(_head->_next);

			//单参数构造函数的类支持隐式类型的转换
			//可以直接这样写,编译器会自动调用iterator
			//的构造函数构造匿名对象返回
			return _head->_next;
		}

		//因为这是双向带头循环链表,而end又是指最后一个元素的下一个位置,
		//所以就是_head的位置
		iterator end()
		{
			return _head;
		}

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

		const_iterator end() const
		{
			return _head;
		}

		size_t size() const
		{
			return _size;
		}

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

			//复用insert即可
			insert(end(), x);
			
		}

		void pop_back()
		{
			//assert(_head->_prev != _head);

			//Node* tail = _head->_prev;
			//Node* tailPrev = tail->_prev;
			//tailPrev->_next = _head;
			//_head->_prev = tailPrev;
			//delete tail;
			//tail = nullptr;

			//复用erase即可
			erase(--end());
		}

		void push_front(const T& x)
		{
			//复用
			insert(begin(), x);
		}

		void pop_front()
		{
			//复用
			erase(begin());
		}

		iterator insert(iterator pos, const T& x)
		{
			//先创建一个新结点
			Node* newNode = new Node(x);
			//先把迭代器转换成节点的指针Node*,方便操作
			Node* cur = pos._node;
			//记录前一个节点
			Node* prev = cur->_prev;

			//更改连接关系,这个就easy了
			prev->_next = newNode;
			newNode->_prev = prev;
			newNode->_next = cur;
			cur->_prev = newNode;

			//最后记得更新_size
			++_size;

			//同样存在隐式类型的转换
			return newNode;
		}

		iterator erase(iterator pos)
		{
			//断言,不能删除哨兵位的头节点
			assert(pos != end());

			//先把迭代器转换成Node*的指针,方便更改连接关系
			Node* cur = pos._node;

			//保存下一个节点
			Node* next = cur->_next;

			//保存前一个节点
			Node* prev = cur->_prev;

			//前一个节点与后一个节点连接起来即可
			prev->_next = next;
			next->_prev = prev;

			//释放要删除的节点
			delete cur;
			cur = nullptr;

			//最后记得--_size
			--_size;

			//同样存在隐式类型的转换
			return next;
		}
	private:
		Node* _head;
		size_t _size;
	};

	void test1(void)
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_back(5);

		lt.insert(lt.begin(), 100);
		lt.erase(lt.begin());
		lt.erase(lt.begin());


		//lt.pop_back();
		//lt.pop_back();
		//lt.pop_back();
		//lt.pop_back();
		//lt.pop_back();


		
		list<int>::iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

	}

	struct A
	{
		A(int x1=0,int x2=0)
			:_a1(x1)
			,_a2(x2)
		{}

		int _a1;
		int _a2;
	};

	void test2()
	{
		list<A> lt;
		lt.push_back(A(1, 1));
		lt.push_back(A(2, 2));
		lt.push_back(A(3, 3));
		lt.push_back(A(4, 4));

		list<A>::iterator it = lt.begin();
		while (it != lt.end())
		{
			//cout << (*it)._a1 << " " << (*it)._a2 << endl;
			cout << it->_a1 << " " << it->_a2 << endl;

			++it;
		}
		cout << endl;
	}

	void test3(void)
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_back(5);

		list<int> lt1(lt);
		for (const auto& e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test4(void)
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_back(5);

		list<int> lt1;
		lt1.push_back(1);

		lt1 = lt;

		lt1.pop_back();
		lt1.pop_back();
		lt1.pop_front();

		for (const auto& e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;

		cout << lt.size() << endl;
		lt.clear();
		cout << lt.size() << endl;
	}
}

以上就是STL容器list常用接口的模拟实现的全部内容了,其实list还有很多接口,但是这些接口是常用的,其它的不常用的接口就不实现了。以上就是今天想要跟大家分享的内容,你学会了吗?如果这篇文章对你有所帮助,那么点点小心心,点点关注呗,后续还会持续更新C++的相关知识哦,我们下期见!!!!!

你可能感兴趣的:(C++,c++,list,windows,数据结构,开发语言,c语言,链表)