【C++】list底层的模拟实现

夜晚中的人海2024-09-06 15:48


个人主页

文章目录

🎄一、前言

list是一个双向链表的容器，它可以在其内部中存储各种类型的元素，并且支持动态地添加、删除和修改元素。

🏠二、基本框架

list可以分为三部分：一个是list节点类，一个是迭代器类，还有一个是list类本身。

它们三个类底层的成员变量又分别代表不同的功能。

其中list节点类封装了list的元素以及前后指针，且完成了节点的初始化。

迭代器类封装了指向节点的指针，还负责重载++、--等运算符。

list类本身负责初始化以及负责插入和删除等功能。

🎡三、list节点类的实现

链表中数据以及前后指针的类型都是由模板自动生成的，可以为内置类型或自定义类型。

cpp 复制代码 
template<class T>
struct list_node
{
	T _data;
	list_node<T>* _next;
	list_node<T>* _prev;

	//构造
	list_node(const T& data = T())
		:_data(data)
		, _next(nullptr)
		, _prev(nullptr)
	{};
};

🎉四、list迭代器类

因为迭代器涉及普通迭代器和const迭代器，因此我们可以使用模板，在模板里面设置三个不同的类型，分别为节点的数据类型、引用类型和指针类型。

cpp 复制代码 
template<class T,class Ref,class Ptr>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> Self;
	//用来访问Node类型的成员变量
	Node* _node;
};

迭代器的默认构造函数因为支持基本的隐式类型转换，因此实现起来也很简单。

cpp 复制代码 
list_iterator(Node* node)
	:_node(node)
{}

1.Ref operator*()

负责重载迭代器的解引用，直接返回当前该迭代器指向的节点数据即可。

cpp 复制代码 
Ref operator*()
{
	return _node->_data;
}

2.Ptr operator->()

由于我们想把迭代器当成指针使用，因此重载->是必要的，其返回值为节点元素的地址。为什么是返回地址呢？这是因为在使用迭代器->时，编译器会自动优化成->->。

cpp 复制代码 
Ptr operator->()
{
	return &_node->_data;
}

3.Self& operator++()前置和Self& operator--()前置

直接让节点指向下一个和前一个即可。

cpp 复制代码 
//前置++
Self& operator++()
{
	_node = _node->_next;
	return *this;
}
//前置--
Self& operator--()
{
	_node = _node->_prev;
	return *this;
}

4.Self operator++(int)后置和Self operator--(int)后置

我们只需把当前迭代器实例化的对象拷贝给一个新的迭代器对象tmp，然后把当前的数据进行处理，最后将tmp进行返回即可。

cpp 复制代码 
//后置++
Self operator++(int)
{
	Self tmp(*this);
	_node = _node->_next;
	return tmp;
}
//后置--
Self& operator--(int)
{
	Self tmp(*this);
	_node = _node->_prev;
	return tmp;
}

5.bool operator!=(const Self& s) const和bool operator==(const Self& s) const

判断节点是否相等不能只判断值是否相等，因为不同的节点可以存放相同的值，因此需要比较其节点是否相等即可。

cpp 复制代码 
bool operator!=(const Self& s) const
{
	return _node != s._node;
}

bool operator==(const Self& s) const
{
	return _node == s._node;
}

⭐五、list类

1.初始化

初始化只需初始化头结点即可。

cpp 复制代码 
//无参初始化
list()
{
	//通过调用这一函数来创建头节点
	empty_init();
}

//空初始化
void empty_init()
{
	_head = new Node;
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}

2.构造函数

当链表为空时，_head节点的头和尾都指向它自己，因此在后续有节点插入时，只需改变一下prev和next指向的位置即可。

cpp 复制代码 
list()
{
	_head = new Node<T>();
	_head->next = _head;
	_head->prev = _head;
}

4.析构函数和clear函数

析构函数是用来释放节点空间的，因此需要先定义一个clear函数用来释放所有的有效节点，确保没有有效节点后再把哨兵位的_head进行删除，然后将_head置为空。

cpp 复制代码 
//析构
~list()
{
	clear();
	delete _head;
	_head = nullptr;
}

void clear()
{
	auto it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}

5.深拷贝

先对其进行空初始化操作，然后用迭代器依次对其进行访问然后插入即可。

cpp 复制代码 
//深拷贝
list(const list<T>& lt)
{
	empty_init();
	for (auto& e : lt)
	{
		push_back(e);
	}
}

6.深赋值

我们可以调用swap函数将两者数据进行交换即可。

cpp 复制代码 
//深赋值
void swap(list<int>& lt)
{
	std::swap(_head, lt._head);
	std::swap(_size, lt._size);
}

list<T>& operator=(list<T> lt)
{
	swap(lt);
	return *this;
}

7.头插和头删函数

头插函数就是每次在begin位置之前进行插入，因为begin是第一个有效的元素；而头删就是每次在begin位置进行删除。

cpp 复制代码 
void push_front(const T& x)
{
	Insert(begin(), x);
}

void pop_front()
{
	erase(--begin());

8.尾插和尾删函数

尾插就是每次在end()位置进行插入，因为end是最后一个有效的元素；而尾删则是在end()的位置上进行删除。

由于我们实现了insert函数，因此就可以调用insert函数在其尾部插入数据即可。

cpp 复制代码 
void push_back(const T& x)
{
	Insert(end(), x);
	++_size;
}

void pop_back()
{
	erase(--end());
}

9.insert和erase函数

insert函数就是在pos位置插入值。

cpp 复制代码 
iterator Insert(iterator pos, const T& x)
{
	//取到pos位置的节点
	Node* cur = pos._node;
	//保留之前的节点
	Node* prev = cur->_prev;
	//创建新节点
	Node* newnode = new Node(x);
	//改变指向，最后更新一下_size
	newnode->_next = cur;
	cur->_prev = newnode;
	newnode->_prev = prev;
	prev->_next = newnode;
	++_size;
	return newnode;
}

erase函数首先要进行断言，防止删除哨兵位。然后将pos位置节点的前和后进行连接，最后删除pos位置的节点，更新一下_size的大小。

cpp 复制代码 
iterator erase(iterator pos)
{
	assert(pos != end());
	Node* prev = pos._node->_prev;
	Node* next = pos._node->_next;
	prev->_next = next;
	next->_prev = prev;
	delete pos._node;
	--_size;
	return next;
}

10.迭代器的实现（普通和const)

由于存在普通成员变量和const成员变量的调用，因此需要实现两个迭代器。

begin迭代器是返回第一个有效位置，由于哨兵位_head并没有数据，因此返回哨兵位的下一个位置。end迭代器是返回最后一个元素的下一个位置，而这个位置是无效的，双向链表无效的位置就只有哨兵位这一个位置，因此返回哨兵位即可。

cpp 复制代码 
iterator begin()
{
	return _head->_next;
}

iterator end()
{
	return _head;
}

//const迭代器
const_iterator begin() const
{
	return _head->_next;
}

const_iterator end() const
{
	return _head;
}

11.判空

直接判断_size是否为空即可。

cpp 复制代码 
//判空
bool empty() const
{
	return _size == 0;
}

12.size()函数

直接返回_size即可。

cpp 复制代码 
size_t size() const
{
	return _size;
}

🚀六、vector和list函数的区别

首先，vector是一个动态数组，在插入和删除数据的时候会挪动后面的元素，这就有可能会导致迭代器失效；而list则为链表，它可以在任意位置进行插入和删除，因此迭代器的稳定性就更高。

其次，vector的迭代器通常为随机访问迭代器，允许向前向后访问元素，而list迭代器可能为双向迭代器，只能向前或向后移动。

最后，vector的随机访问速度快，因此在查找元素时的效率高，但如果频繁的插入或者删除元素时，list通常会更快，因为它不需要移动大量的元素。

🏝️七、源代码

cpp 复制代码 
#include<iostream>
#include<assert.h>
#include<list>
using namespace std;

namespace bit
{
	template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;

		//构造
		list_node(const T& data = T())
			:_data(data)
			, _next(nullptr)
			, _prev(nullptr)
		{};
	};
	//const迭代器
	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++(int)
		{
			Self tmp(*this);
			_node = _node->_next;
			return tmp;
		}

		//前置--
		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		//后置--
		Self& operator--(int)
		{
			Self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

		bool operator!=(const Self& s) const
		{
			return _node != s._node;
		}

		bool operator==(const Self& s) const
		{
			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;

		iterator begin()
		{
			return _head->_next;
		}

		iterator end()
		{
			return _head;
		}

		//const迭代器
		const_iterator begin() const
		{
			return _head->_next;
		}

		const_iterator end() const
		{
			return _head;
		}

		//空初始化
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		//无参初始化
		list()
		{
			empty_init();
		}

		//析构
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		//深拷贝
		list(const list<T>& lt)
		{
			empty_init();
			for (auto& e : lt)
			{
				push_back(e);
			}
		}

		//深赋值
		void swap(list<int>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		size_t size() const
		{
			return _size;
		}

		void push_back(const T& x)
		{
			Insert(end(), x);
			++_size;
		}

		iterator Insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* newnode = new Node(x);
			newnode->_next = cur;
			cur->_prev = newnode;
			newnode->_prev = prev;
			prev->_next = newnode;
			++_size;
			return newnode;
		}
	
		void pop_back()
		{
			erase(--end());
		}

		void pop_front()
		{
			erase(--begin());
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;
			prev->_next = next;
			next->_prev = prev;
			delete pos._node;
			--_size;
			return next;
		}

		void push_front(const T& x)
		{
			Insert(begin(), x);
		}

		//判空
		bool empty() const
		{
			return _size == 0;
		}
	
	private:
		Node* _head;
		size_t _size;
	};
}
相关推荐
唐诺2 小时前
几种广泛使用的 C++ 编译器
c++·编译器
冷眼看人间恩怨3 小时前
【Qt笔记】QDockWidget控件详解
c++·笔记·qt·qdockwidget
红龙创客3 小时前
某狐畅游24校招-C++开发岗笔试（单选题）
开发语言·c++
Lenyiin3 小时前
第146场双周赛：统计符合条件长度为3的子数组数目、统计异或值为给定值的路径数目、判断网格图能否被切割成块、唯一中间众数子序列 Ⅰ
c++·算法·leetcode·周赛·lenyiin
Clockwiseee4 小时前
php伪协议
windows·安全·web安全·网络安全
yuanbenshidiaos4 小时前
c++---------数据类型
java·jvm·c++
十年一梦实验室5 小时前
【C++】sophus : sim_details.hpp 实现了矩阵函数 W、其导数，以及其逆 (十七)
开发语言·c++·线性代数·矩阵
taoyong0015 小时前
代码随想录算法训练营第十一天-239.滑动窗口最大值
c++·算法
这是我585 小时前
C++打小怪游戏
c++·其他·游戏·visual studio·小怪·大型·怪物
唐宋元明清21885 小时前
.NET 阻止系统睡眠/息屏
windows·电源
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程