STL容器 -- 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 <iostream>
using namespace std;
#include <assert.h>

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++的相关知识哦，我们下期见！！！！！文章来源地址https://www.toymoban.com/news/detail-575294.html

到了这里，关于STL容器 -- list的模拟实现（配详细注释）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！