C++初阶学习——探索STL奥秘——模拟实现list类

news2024/11/15 5:08:37

1、基本框架

list 由三个类构建而成:

节点类:每个节点必须的三部分(指向前一个节点的指针、指向后一个节点的指针、当前节点存储的数据)

迭代器类:此时的迭代器为双向迭代器，比较特殊，需要对其进行封装，如 it++并非使迭代器单纯向后移动，而是让其指向下一个节点

链表类:实现链表各项功能的类，为主要部分

1.1、节点类

节点类在设计时，需要确定三个成员和构造函数，用来生成类

//节点类
template<class T>
struct __list_node
{
	__list_node(const T& data = T())
		:_prev(nullptr)
		,_next(nullptr)
		,_data(data)
	{}

	__list_node<T>* _prev;	//指向前一个节点
	__list_node<T>* _next;	//指向后一个节点
	T _data;	//存储相应数据
};

注意: 节点的创建与销毁，不在节点类中进行，因此不需要写析构函数

1.2、迭代器类

迭代器类中的成员为节点类指针，指向单个节点，同样的，选代器类也需要提供构造函数 

//迭代器类
template<class T>
struct __list_iterator
{
	typedef __list_node<T>* link_type;	//对节点类的指针，进行重命名

	__list_iterator(link_type node)
		:_node(node)
	{}

	link_type _node;
};

注意: 迭代器只是一个辅助工具，指向的是节点，同样不需要提供析构函数，析构相关事宜交给链表类处理就好

1.3链表类

链表类中也只用有一个成员变量:哨兵位节点(头节点)

//list本类
template<class T>
class list
{
	typedef __list_node<T> node;	//节点
	typedef T value_type;	//模板参数值
	typedef T& refence;	//引用
	typedef const T& const_refence;	//const 引用

private:
	node* _head;	//哨兵位节点（头节点）
};

2、默认成员函数

默认成员函数中包含了默认构造、带参构造、拷贝构造、赋值重载和析构函数

析构函数只负责释放链表中的节点，而其他默认成员函数负责 构造/构建出其他对象

因为有很多构造函数中都需要对创建出头节点，所以此时 需要先构建出一个空初始化函数empty init()，这个函数只能在类中使用

因此设为 private

private:
	//初始化出头节点
	void empty_init()
	{
		_head = new node;
		_head->_prev = _head->_tail = _head;
	}

其他构造函数在构造对象前，可以先调用此函数

比如默认构造函数， 构成出一个空对象

//默认构造函数
list() { empty_init(); }

对于带参构造函数，在构造对象前，仍需要调用 empty_init()构建头节点
参数:

size_t n 对象中包含 n 个数据
const reference val 数据值

为了避免与后续的迭代器区间构造起冲突，这里需要再额外提供一个 int版本

//带参构造函数(value_type)，此处的value_type指的就是就是模版参数T
list(value_type n, const_refence val = value_type())
{
	empty_init();
	while (n--) push_back(val);
}
//为了避免与迭代器区间构造函数冲突，提供额外版本(int)
list(int n, const_refence val = value_type())
{
	empty_init();
	while (n--) push_back(val);
}

在实际创建 list 对象时，多使用迭代器区间进行构造，因为是创建新对象，所以可以直接调用尾插进行创建 

//迭代器区间构造
template<class InputIterator>
list(InputIterator first, InputIterator last)
{
	empty_init();
	while (first != last) push_back(*first++);
}

关于拷贝构造和赋值重载，可以使用现代写法

//交换
void swap(list<T>& tmp)
{
	std::swap(_head, tmp._head);
}
//拷贝构造---现代写法
list(const list<T>& x)
{
	empty_init();
	list<T> tmp(x.begin(), x.end());
	swap(tmp);
}
//赋值重载---现代写法
list<T>& operator=(list<T> tmp)
{
	swap(tmp);
	return *this;
}

 注意:

以上几种构造函数都是在创建新对象，因此在构建前，需要先调用 empty_init()初始化出头节点

为了避免 list(int，int)匹配上迭代器区间构造，可以再额外提供一个int版的带参构造函数。

拷贝构造的参数必须使用引用，否则会造成无穷递归问题

至于析构函数的实现就很简单了，直接使用函数 clear()释放节点，最后再释放头节点即可

//析构函数
~list()
{
	clear();	//后续会对这个函数的实现进行讲解
	delete _head;
	_head = nullptr;
}

3、迭代器设计 

 3.1、多参数模板

list 的模拟实现精华在于迭代器类的设计，而迭代器类中的精华在于多参数模板，这种传多模板参数的方法，巧妙的解决了正常对象与const 对象的冗余设计问题

选代器分为 iterator 和 const iterator，不同的对象调用不同的迭代器类型，假设不使用多参数模板，就需要实现两份相差不大的迭代器类(完全没有必要)

T:节点中值的普通类型

Ref :节点中值的引用类型(可为const）

Ptr:节点中值的指针类型(可为const）

//迭代器类
template<class T, class Ref, class Ptr>
struct __list_iterator
{
	typedef __list_node<T>* link_type;
	typedef __list_iterator<T, Ref, Ptr> self;

		__list_iterator(link_type node)
		:_node(node)
	{}

	link_type _node;
};

//=====迭代器设计=====（list 类中）
typedef __list_iterator<T, T&, T*> iterator;	//声明两种不同的迭代器
typedef __list_iterator<T, const T&, const T*> const_iterator;

他是一个要单独存在的类

注意: 节点类及迭代器类都是使用 struct 定义的，目的是为了开放其中的成员
list 类中的迭代器相关函数也有两种:

普通版本与 const 版本

规定:

begin()为 list 的头节点的下一个节点

end()是 list 的头节点

返回类型都为迭代器对象，因此可以使用匿名对象进行构造

//=====迭代器设计=====
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_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 const_iterator(_head); }

迭代器分类:

单向迭代器:支持++或--其中一种移动方式
双向迭代器:支持++及--两种移动方式
随机迭代器:不仅支持 ++ 和 -，还支持迭代器 +n、-n

只有随机选代器才能使用 std::sort 进行快速排序 

3.2双向迭代器

对于双向链表，我们要实现双向迭代器

self& operator++();	//前置++

self& operator--();	//前置--

self operator++(int);	//后置++

self operator--(int);	//后置--

list 中的双向迭代器在进行移动时也比较特殊，不像之前的 string 和 vector 是连续空间(移动直接调用内置 ++/--)
list 为非连续空间，迭代器在移动时为前后节点间的移动，使用内置 ++/-- 会引发严重的迭代器越界问题
因此才需要将迭代器单独封装为一个类，实现我们想要的效果 

实现代码：

self& operator++()
{
	_node = _node->_next;

	return *this;
}

self& operator--()
{
	_node = _node->_prev;

	return *this;
}

self operator++(int)
{
	self tmp(_node);

	//++_node;	//谨防错误写法
	//_node = _node->_next;	//正确写法1
	++(*this);	//正确写法2
	return tmp;
}

self operator--(int)
{
	self tmp(_node);

	//--_node;	//谨防错误写法
	//_node = _node->_prev;	//正确写法1
	--(*this);	//正确写法2
	return tmp;
}

 注意：

//以下是后置++的错误写法
self operator++(int)
{
	self tmp(_node);

	++_node;	//错误写法
	return tmp;
}

node 是一个节点指针，非迭代器对象，++ node 不是在调用 operator++()，而是在调用内置的前置 ++(节点指针没有像迭代器一样进行重载)，直接++就指向了非法空间

解决方案:

1.手动实现节点的移动:
node = node-> next

2.调用迭代器类的前置 ++:
++(*this) 

3.3指向结构体成员功能

		Ptr operator->()
		{
			return &_node->_val;
		}

运用场景： 

当 list 中的对象为自定义类型时，，想直接通过 it->访问其中的成员

struct A
{
	A(int a = int(), double b = double(), char c = char())
		:_a(a)
		,_b(b)
		,_c(c)
	{}

	int _a;
	double _b;
	char _c;
};

void TestList()
{
	list<A> lt;
	lt.push_back(A(1, 2.2, 'A'));
	
	auto it = lt.begin();
	cout << (*it)._a << endl;	//不使用 operator->() 比较别扭
	cout << it->->_b << endl;	//这种写法是真实调用情况
	cout << it->_c << endl;	//编译器直接优化为 it->
}

3.4迭代器总代码

//迭代器类
template<class T, class Ref, class Ptr>
struct __list_iterator
{
	typedef __list_node<T>* link_type;
	typedef __list_iterator<T, Ref, Ptr> self;

	__list_iterator(link_type node)
		:_node(node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &(operator*());
	}

	self& operator++()
	{
		_node = _node->_next;

		return *this;
	}
	
	self& operator--()
	{
		_node = _node->_prev;

		return *this;
	}

	self operator++(int)
	{
		self tmp(_node);
		
		//++_node;	//谨防错误写法
		//_node = _node->_next;	//正确写法1
		++(*this);	//正确写法2
		return tmp;
	}

	self operator--(int)
	{
		self tmp(_node);

		//--_node;	//谨防错误写法
		//_node = _node->_prev;	//正确写法1
		--(*this);	//正确写法2
		return tmp;
	}

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

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

	link_type _node;
};

4.容量

list 中的容量访问有:判空和大小
实现判空:判断当前的 begin()与 end()是否相同
统计大小:利用迭代器将整个 list 遍历一遍，计数统计即可

//=====容量相关=====
bool empty() const { return begin() == end(); }
size_t size() const 
{
	int cnt = 0;
	auto it = begin();	//使用 auto 自动推导迭代器类型
	while (it != end())
		++it, ++cnt;

	return cnt;
}

5、数据访问

STL 库中给 list 提供了两种数据访问方式:访问首个数据和访问最后一个数据

//=====数据访问=====
refence front() { return *begin(); }
const_refence front() const { return *begin(); }

refence back() { return *(--end()); }
const_refence back() const { return *(--end()); }

6、数据修改相关

只需要找到对应节点的位置，插入/删除本质上就是在进行前后节点的链接关系修改

6.1、头尾插删

头尾插删是在对 begin()和 --end()所指向的节点进行操作，尾部插入/头部删除，逻辑一致，尾部删除/头部删除 逻辑一致学会其中一个就够用了

尾部插入步骤:

根据传入的数值，构建出新尾节点 new_back
找到原链表中的尾节点 old_back
在 old back、new back、 head 间建立链接关系即可

头部插入逻辑与尾部插入基本一致，不过找的是 old_front 头节点

//尾插
void push_back(const_refence val)
{
	node* new_back = new node(val);

	node* old_back = _head->_prev;

	old_back->_next = new_back;	//原尾节点的 _next 指向新尾节点
	new_back->_prev = old_back;	//新尾节点的 _prev 指向原尾节点

	new_back->_next = _head;	//新尾节点的 _next 指向头节点
	_head->_prev = new_back;	//头节点的 _prev 指向新尾节点
}

尾部删除步骤：

断言当前 list 不为空，如果为空，就报错

选择原来的尾节点 old_back-> head-> prev

确定新的尾节点 new back->old back->prev

在 new_back 与 head 之间建立链接关系

最后在释放原来的尾节点 old back

头删时，逻辑基本一致，不过选择的是old_front与 new_front 

//尾删
void pop_back()
{
	assert(!empty());

	node* old_back = _head->_prev;	//选择原尾节点
	node* new_back = old_back->_prev;	//确定新尾节点

	new_back->_next = _head;	//新尾节点的 _next 指向头节点
	_head->_prev = new_back;	//头节点的 _prev 指向新尾节点

	delete old_back;
}

6.2、任意位置插删

任意位置插入就是在插入操作的基础上添加了迭代器pos进行定位

在 pos位置前插入

根据传入值，创建出新节点 new_node

确定当前 pos 位置的节点 pos_cur

确定当前 pos 位置的上一个节点 pos_prev

在 pos_prev、new_node、pos_cur 间建立链接关系

最后返回当前插入新节点的位置

//任意位置插入
iterator insert(iterator pos, const_refence val)
{
	node* new_node = new node(val);	//创建新节点

	node* pos_cur = pos._node;	//当前 pos 位置的节点
	node* pos_prev = pos_cur->_prev;	//pos 的前一个节点

	pos_prev->_next = new_node;	
	new_node->_prev = pos_prev;

	new_node->_next = pos_cur;
	pos_cur->_prev = new_node;

	return iterator(new_node);	//最后返回的是一个迭代器对象
}

任意位置删除逻辑与 尾删/头删 基本一致
首先断言 list 是否为空
分别确定当前节点 pos_cur，上一个节点 pos_prev，
下一个节点 pos_next
在上下节点 pos_prev 和 pos_next 间建立链接关系
删除当前节点 pos_cur
返回己删除节点下一个节点，即pos_next

//任意位置删除
iterator erase(iterator pos)
{
	assert(!empty());

	node* pos_cur = pos._node;

	node* pos_prev = pos_cur->_prev;
	node* pos_next = pos_cur->_next;

	pos_prev->_next = pos_next;
	pos_next->_prev = pos_prev;

	delete pos_cur;

	return iterator(pos_next);
}

list 的插入操作没有迭代器失效问题，删除操作也仅仅是影响被删除节点的迭代器，返回值是为了更好的进行操作
注意:
之前提到的 尾部插入/删除、头部插入/删除 可以复用任意位置插入/删除

//尾插
void push_back(const_refence val)
{
	insert(end(), val);
}

//尾删
void pop_back()
{
	erase(--end());
}

//头插
void push_front(const_refence val)
{
	insert(begin(), val);
}

//头删
void pop_front()
{
	erase(begin());
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2138418.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

QT添加图标标题和打包项目

QT添加图标标题和打包项目

QT项目打包 项目的标题和图标标题项目图标exe图标 可执行文件——生成exeexe运行报错“找不到qt6gui.dll”等 相关库文件——生成zip安装包打包程序——生成exe安装包 项目的标题和图标 项目打包要好看点&#xff0c;得有个好点的标题和图标&#xff0c;这次打包的项目是我上一…
阅读更多...
excel如何快速选中某个数字或者某串数字

excel如何快速选中某个数字或者某串数字

鼠标光标放在某个数字或者某串数字的末尾&#xff0c;进行双击鼠标左键即可 &#xff08;就会选中当前鼠标光标前相邻的所有数字&#xff09;&#xff1a;
阅读更多...
【Node.js】RabbitMQ 延时消息

【Node.js】RabbitMQ 延时消息

概述 在 RabbitMQ 中实现延迟消息通常需要借助插件&#xff08;如 RabbitMQ 延迟队列插件&#xff09;&#xff0c;因为 RabbitMQ 本身不原生支持延迟消息。 延迟消息的一个典型场景是&#xff0c;当消息发布到队列后&#xff0c;等待一段时间再由消费者消费。这可以通过配置…
阅读更多...
【拦截导弹】

【拦截导弹】

​ 题目 ​​ 题解 题解&#xff1a;1010. 拦截导弹&#xff08;dp与贪心&#xff09; - AcWing 我谈几点&#xff1a; 第一&#xff0c;由此复习了upper_bound和lower_bound函数 第二&#xff0c;由此学习了贪心方式求“最多分割不严格递减子序列的数目”和“最长不严格递…
阅读更多...
算法参数对拥塞控制的影响

算法参数对拥塞控制的影响

来看看参数对公平收敛的影响。仅假象一下就知道应该是个加权公平&#xff0c;但事实如何&#xff0c;还是要具体看一下。 首先看 aimd&#xff0c;标准的 reno 算法是每 round 之后 cwnd 加 1&#xff0c;但如果有些流加 1&#xff0c;有些流加 2&#xff0c;会如何&#xff1…
阅读更多...
踩坑【已解决】：使用maven打印结果是控制台输出中文乱码

踩坑【已解决】：使用maven打印结果是控制台输出中文乱码

报错原图&#xff1a; 解决方案&#xff1a; 1、修改maven->runner中的配置添加如下信息&#xff1a; -Dfile.encodingUTF-8 2、检查编码的配置信息&#xff1a; 3、检查窗口右下角的配置信息&#xff1a; 解决结果&#xff1a;
阅读更多...
SEGGERS实时系统embOS推出Linux端模拟器

SEGGERS实时系统embOS推出Linux端模拟器

SEGGER 发布了两个新的 embOS 仿真模拟器&#xff1a;embOS Sim Linux 和 embOS-MPU Sim Linux。 通过模拟 Linux 主机系统上的硬件&#xff0c;取代物理硬件&#xff0c;为开发人员提供了一种无缝的方式来构建原型和测试应用程序。 embOS Sim Linux 端口支持 32 位和 64 位系…
阅读更多...
【在Linux世界中追寻伟大的One Piece】网络命令|验证UDP

【在Linux世界中追寻伟大的One Piece】网络命令|验证UDP

目录 1 -> Ping命令 2 -> Netstat命令 3 -> Pidof命令 4 -> 验证UDP-Windows作为client访问Linux 4.1 -> UDP client样例 1 -> Ping命令 Ping命令是一种网络诊断工具&#xff0c;它使用ICMP(Internet Control Message Protocol&#xff0c;互联网控制消…
阅读更多...
CAN BUS

CAN BUS

CAN BUS 原理 网上资料非常丰富&#xff0c;是车载系统主要BUS之一。 我们关注如下方面 can bus 是什么网络结构CAN BUS 协议ECU node实现其他 What is CAN Bus? Control Area Network (CAN) bus is a serial communication protocol that allows devices to exchange dat…
阅读更多...
MySQL：视图【详解】

MySQL：视图【详解】

1、视图 1.1 视图的定义 视图是在数据库中定义的虚拟表。它是一个基于一个或多个实际表的查询结果集&#xff0c;可以像实际表一样被查询和操作。视图可以看作是一个动态生成的数据表&#xff0c;其内容是从其他表中选择、过滤和计算得到的。 视图通过使用SQL查询语句来定义…
阅读更多...
Framebuffer应用编程

Framebuffer应用编程

目录 前言 LCD操作原理 涉及的 API 函数 open函数 ioctl 函数 mmap 函数 Framebuffer程序分析 源码 1.打开设备 2.获取LCD参数 3.映射Framebuffer 4.描点函数 5.随便画几个点 上机实验 前言 本文介绍LCD的操作原理和涉及到的API函数&#xff0c;分析Framebuffer…
阅读更多...
配置全新服务器深度学习一套流程

配置全新服务器深度学习一套流程

目录 1.安装anaconda2.配置cuda3.配置cudnn4.配置新的pytorch环境5.安装rdkit包6.小问题记录 1.安装anaconda 直接参考视频 总结&#xff1a; 1.下载anaconda安装包&#xff0c;尽量不下载最新的版本 2.bash 对应安装包&#xff0c;一直回车&#xff0c;yes 3.配置环境vim ~/.…
阅读更多...
点餐小程序实战教程10权限验证

点餐小程序实战教程10权限验证

目录 1 创建员工的全局变量2 创建员工首页3 跳转到员工首页4 给全局变量赋值5 验证权限6 登录的完整代码总结 我们已经实现了员工的注册及登录功能&#xff0c;登录成功后需要跳转到我们的员工首页。在首页加载的时候我们需要去验证当前用户是否已经登录&#xff0c;未登录我就…
阅读更多...
深入理解数据分析的使用流程：从数据准备到洞察挖掘

深入理解数据分析的使用流程：从数据准备到洞察挖掘

数据分析是企业和技术团队实现价值的核心。 5 秒内你能否让数据帮你做出决策&#xff1f; 通过本文&#xff0c;我们将深入探讨如何将原始数据转化为有意义的洞察&#xff0c;帮助你快速掌握数据分析的关键流程。 目录 数据分析的五个核心步骤1. 数据获取常用数据获取方式 2. 数…
阅读更多...
synchronized的详解、锁的升级过程和优缺点比较

synchronized的详解、锁的升级过程和优缺点比较

本文 详细介绍Java中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级 锁、重量级锁&#xff0c;以及锁升级过程。 Java中每一个对象都可以作为锁。具体表现形式为以下三种形式&#xff1a; 对于普通的同步方法&#xff0c;锁是当前的实例对象对于静态同步方法&a…
阅读更多...
攻防世界---＞秘密-银河-300

攻防世界---＞秘密-银河-300

做题笔记。 适用于reverse的隐写术。。。。啊哈哈哈哈 下载 查壳。(用的WSL->Debian) 64ida打开。 运行程序如下&#xff1a; 反汇编看不出来什么名堂&#xff0c;那就去看汇编代码。 下个断点。 东看看西看看 这是我们程序打印代码 往下翻&#xff1a; SECRET 秘密。 我…
阅读更多...
路径规划 | 基于A*算法的往返式全覆盖路径规划的改进算法（Matlab）

路径规划 | 基于A*算法的往返式全覆盖路径规划的改进算法（Matlab）

目录 效果一览基本介绍程序设计参考文献 效果一览 基本介绍 基于A*算法的往返式全覆盖路径规划的改进算法 matlab实现代码 往返式全覆盖路径规划&#xff0c;通过建立二维栅格地图&#xff0c;设置障碍物&#xff0c;以及起始点根据定义往返式路径规划的定义的优先级运动规则从…
阅读更多...
网页本地存储

网页本地存储

网页本地存储 <html> <script>//添加数据function add(){var text;textdocument.getElementById(text).value;indexlocalStorage.length1;localStorage.setItem(index,text);}//显示localStorage所有内容function showall(){storagelocalStorage;var length stor…
阅读更多...
209.长度最小的子数组(滑动窗口类）

209.长度最小的子数组(滑动窗口类）

文章目录 209.长度最小的子数组滑动窗口904. 水果成篮76. 最小覆盖子串 209.长度最小的子数组 209.长度最小的子数组 给定一个含有 n 个正整数的数组和一个正整数 s &#xff0c;找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组&#xff0c;并返回其长度。如果不存在符合…
阅读更多...
2020ICPC上海 D - Walker M - Gitignore

2020ICPC上海 D - Walker M - Gitignore

D: 首先显然要二分,判断当前二分的mid时间下是否能满足走满0~n 枚举所有情况,这里按照左,右起点p1,p2分别讨论 p1向左 p2向左(以下向左和向右都代表向左或者向右到墙,而不代表初速度方向)&#xff0c;只需要计算p1或者p2反弹之后还能走距离n就是合法 p1向左 p2向右&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023