【C++初阶】STL详解（八）List的模拟实现

news2024/12/25 8:50:29

本专栏内容为：C++学习专栏，分为初阶和进阶两部分。 通过本专栏的深入学习，你可以了解并掌握C++。

💓博主csdn个人主页：小小unicorn
⏩专栏分类：C++
🚚代码仓库：小小unicorn的代码仓库🚚
🌹🌹🌹关注我带你学习编程知识

STL详解（八）

  • list的再认识：
  • 初始化与定义节点：
  • 迭代器实现：
    • 构造：
    • ++
    • 解引用：*
    • ！=
    • 基本框架搭建：
    • --
    • 后置++与后置--
    • ->
    • ==
    • const迭代器
      • 拓展：
      • 拓展2：
  • 相关函数接口：
    • Insert：
    • erase:
    • push_front与pop_fronr
    • push_back与pop_back
    • size:
    • clear与析构：
    • 拷贝构造：
    • 赋值重载：
      • 传统写法：
      • 现代写法：
  • 对比vector与list

list的再认识：

在之前List的介绍与使用中，我们知道list容器是一个带头双向循环链表，那么我们在模拟实现中，能不能先证明一下List是否是一个双向循环链表呢？

我们参考一下stl中list的源码：
在这里插入图片描述
我们看到，在源码中，list中有一个__list_node的节点，我们将这个链表的节点定义打开发现定义两个指针next，prev.

再来看一下它的空初始化：
在这里插入图片描述
通过观察源码中list的初始化，确实是一个双向循环链表。

接下来。我们就来自己实现一下里面的接口函数。
注意：在模拟实现中，我们采取用与与源码中相同的命名风格。
为防止与库里面的list重复，我们模拟实现将定义在自己的命名空间中。

初始化与定义节点：

首先，我们需要定义三个类，并用摸版进行封装：分别是list，list的节点，以及迭代器：

list节点：

template<class T>
struct list_node
{
	T _data;
	list_node<T>* _next;
	list_node<T>* _prev;
	list_node(const T& x=T())
	:_data(x)
	,_next(nullptr)
	,_prev(nullptr)
{}
};

list:

template<class T>
class list
{
	typedef list_node<T> Node;
public:
	//空初始化：
	void empty_init()
	{
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;
	}
	//无参构造：
	list()
	{
		empty_init();
	}

	void push_Back(const T& x)
	{
		Node* tail = _head->_prev;
		Node* newnode = new Node(x);

		tail->_next = newnode;
		newnode->_prev = tail;

		newnode->_next = _head;
		_head->_prev = newnode;
	}
private:
	Node* _head;
};

这里我们写的是无参构造，以及实现了一个尾插接口：
尾插双向链表实现已经再简单不过了：
在这里插入图片描述
现在我们测试一下：
在这里插入图片描述
现在还不能进行遍历，因此我们自己要实现一个迭代器：

迭代器实现：

那么这个迭代器我们要作为怎么实现呢？
我们可以先回顾一下，在vector中，我们实现迭代器就是实现原生指针。
在这里插入图片描述
在vector中，给it解引用就可以访问到里面的数据，但是链表不行，因为链表中空间不是连续的。
那么应该怎么实现呢？其实这个就和我们之前的日期类一样，在日期类中我们用运算符重载与封装实现了对日期类的++操作。而我们的迭代器也使这样实现的。

这里我们需要实现迭代器的！=，*与++操作：
在这里插入图片描述
我们先看一下库里面的操作：
在这里插入图片描述

构造：

看一下库里面的操作：
在这里插入图片描述
库里面用了一个节点的指针进行构造，这是因为：单参数的构造函数支持隐式类型转换。

所以我们的构造就可以这样写：

__list_iterator(Node* node)
	:_node(node)
{
}

++

实现迭代器++，就是指针往后走的过程，注意返回的是迭代器。我们可以将迭代器重命名一下：

typedef __list_iterator<T> self;

实现代码：

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

解引用：*

返回节点里面的数据即可：

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

！=

两个迭代器进行比较，实质两个指针比较。

//两个迭代器进行比较，两个指针比较
bool operator!=(const self& s)
{
	return _node  !=  s._node;
}

基本框架搭建：

这样基本上迭代器的基本架子就完成了：

typedef __list_iterator<T> iterator;
iterator begin()
{
	return _head->_next;
}
iterator end()
{
	return _head;
}

在list中定义一下迭代器。迭代器开始位置就是返回哨兵位头节点的下一个位置，结束位置就是返回哨兵位的地址。

测试一下：

void test_list1()
	{
		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>::iterator it = lt.begin();
		while (it != lt.end())
		{
			//*it += 20;
			cout << *it << " ";
			++it;
		}
		cout << endl;
}

测试结果：
在这里插入图片描述
有了迭代器就有范围for：

for (auto e : lt)
{
	cout << e << " ";
}
cout << endl;

在这里插入图片描述
总结：其实会发现就是在模拟指针，但他的底层细节很大。所以迭代器体现了封装的强势之处。封装屏蔽底层差异和实现细节，提供统一的访问修改遍历方式。这样我们就不用关注他的底层是什么.
在这里插入图片描述

举个例子：

	set<int> s;
	s.insert(1);
	s.insert(3);
	s.insert(2);
	s.insert(4);

	set<int>::iterator sit = s.begin();
	while (sit != s.end())
	{
		cout << *sit << " ";
		++sit;
	}
	cout << endl;
}

在这里插入图片描述
这里的set就是树，我们也可以依然用这个迭代器进行遍历。

–

实现迭代器++，就是指针往前走的过程，注意返回的是迭代器。

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

后置++与后置–

//后置
self operator++(int)
{
	self tmp(*this);
	_node = _node->_next;
	return tmp;
}
//后置
self operator--(int)
{
	self tmp(*this);
	_node = _node->_prev;
	return tmp;
}

->

在讲->重载之前，先看一下这个示例：

struct AA
{
	AA(int a1 = 0, int a2 = 0)
		:_a1(a1)
		, _a2(a2)
	{}

	int _a1;
	int _a2;
};
list<AA> lt;
lt.push_back(AA(1, 1));
lt.push_back(AA(2, 2));
lt.push_back(AA(3, 3));

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

在这里就访问不了，因为自定义类型不支持类型。

这里我们回顾一下之前的知识，对与内置类型的指针，我们可以采用*来进行解引用。对于自定义类型的指针，我们要用->来进行解引用。

int* p = new int;
*p = 1;

AA* ptr = new AA;
ptr->_a1 = 1;

实现->

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

==

两个迭代器进行比较，就是两个指针比较

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

const迭代器

在实现const迭代器之前，首先要知道一点，const迭代器是一个完全不一样的类，所以不能将非const迭代器前加const就变成const迭代器。
在这里插入图片描述
因此我们可以list类中在定义一个const迭代器：

typedef __list_const_iterator<T> const_iterator;

const_iterator begin() const
{
	return _head->_next;
}
const_iterator end() const
{
	return _head;
}

在单独实现一个const迭代器的类：

template<class T>
struct __list_const_iterator
{
   ....
}

const迭代器基本的功能与非const迭代器相似，只有在解引用时不同：

// *it = 10
const T& operator*()
{
	return _node->_data;
}

// it->a1 = 10
const T* operator->()
{
	return &_node->_data;
}

测试一下：

void print_list(const list<int>& lt)
{
	list<int>::const_iterator it = lt.begin();
	while (it != lt.end())
	{
		//*it = 10;
		cout << *it << " ";
		++it;
	}
	cout << endl;

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
}

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

	print_list(lt);
}

在这里插入图片描述
但是这样实现，还是太冗余了，因为非const和const只有返回值不同，那么还有优化的空间吗？
我们看一下库里面的实现:
在这里插入图片描述
库里面定义只定义了同一个类模版的迭代器，只是这两个迭代器之间的摸版参数不同，实例化的参数不同，就是完全不一样的类型。也就是说把能靠模版实现的就写一份，让编译器搞。

所以我们可以将我们的迭代器进行进一步优化：

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;
	....
}

// T T& T*
// T cosnt T& const T*
template<class T, class Ref, class Ptr>
struct __list_iterator
{
	typedef list_node<T> Node;
	/*typedef __list_iterator<T> self;*/
	typedef __list_iterator<T, Ref, Ptr> self;
	Node* _node;
	...
}

到这里，我们的迭代器就全部实现完了。

拓展：

在刚才的测试函数中，有一个print_list函数，但是这个测试函数里面的数据我们给定的是int,那我要是其他类型的呢，这个函数又该如何修改呢？
其实很简单：我们加一个摸版参数即可：

template<typename T>
void print_list(const list<T>& lt)
{
	typename list<T>::const_iterator it = lt.begin();
	while (it != lt.end())
	{
		//*it = 10;
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

测试一下：
在这里插入图片描述
注意：这里我们没有用class这个摸版参数，这是因为：

list是一个未实例化的类模板，编译器不能去他里面去找
编译器就无法确定：list::const_iterator是内嵌类型，还是静态成员变量
前面加一个typename就是告诉编译器，这里是一个类型，等list实例化后再去类里面去取

拓展2：

如果要是将刚才的类在改造一下呢？
比如：
我要打印以下内容：

vector<string> v;
v.push_back("222222222222222222222");
v.push_back("222222222222222222222");
v.push_back("222222222222222222222");
v.push_back("222222222222222222222");

这个函数对于我们的printf_list就不适用了，因为我们的print_list就只适用于链表。
这里我们就可以写一个容器（container）的打印函数：

template<typename Container>
void print_Container(const Container& con)
{

	typename Container::const_iterator it = con.begin();
	while (it != con.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

测试结果：
在这里插入图片描述
总结一下：
摸版实现了泛型编程，而泛型编程的本质，就是本来我们干的活，交给了编译器。

相关函数接口：

有了迭代器的实现，我们就可以实现一下链表的相关接口：

Insert：

Insert:在pos位置之前插入：

iterator insert(iterator pos, const T& x)
{
	Node* cur = pos._node;
	Node* newnode = new Node(x);

	Node* prev = cur->_prev;

	// prev newnode cur
	prev->_next = newnode;
	newnode->_prev = prev;
	
	newnode->_next = cur;
	cur->_prev = newnode;
	
	++_size;
	return iterator(newnode);
}

Insert迭代器不会产生失效的问题，因为没有扩容。

erase:

在指定位置删除：

iterator erase(iterator pos)
{
		Node* cur = pos._node;
		Node* prev = cur->_prev;
		Node* next = cur->_next;

			delete cur;
			prev->_next = next;
			next->_prev = prev;

			--_size;
			return iterator(next);
}

注意：erase的迭代器会失效，所以我们加个返回值。

实现了insert和erase后，我们就可以服用来实现头插，头删，尾插，尾删。

push_front与pop_fronr

具体实现：

头插：

//头插
void push_front(const T& x)
{
	insert(begin(), x);
}

头删：

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

push_back与pop_back

具体实现：

尾插：

void push_back(const T& x)
{
	insert(end(), x);
}

尾删：

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

size:

为了方便计算大小，我们还可以再实现一个函数：

size_t size()
{
	return _size;
}

clear与析构：

clear：清理空间，我们可以采取迭代器访问的方式，逐个将节点释放。

//清理空间：
void clear()
{
	iterator it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}

析构：我们可以先清理空间，在将头节点释放即可。

//析构
~list()
{
	clear();

	delete _head;
	_head = nullptr;
}

拷贝构造：

我们可以采用范围for来进行拷贝构造：

//拷贝构造：
// lt2(lt1)
//list(const list<T>& lt)
list(list<T>& lt)
{
	empty_init();
	for (auto e : lt)
	{
		push_back(e);
	}
}

赋值重载：

传统写法：

list<int>& operator=(const list<int>& lt)
{
	if (this != &lt)
	{
		clear();
		for (auto e : lt)
		{
			push_back(e);
		}
	}

	return *this;
}

现代写法：

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

// lt3 = lt1
list<int>& operator=(list<int> lt)
{
	swap(lt);

	return *this;
}

对比vector与list

在这里插入图片描述

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

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

相关文章

JOSEF约瑟 JHOK-ZBZ201智能型漏电（剩余）继电器 导轨安装

JOSEF约瑟 JHOK-ZBZ201智能型漏电（剩余）继电器 导轨安装

JHOK-ZBZ漏电继电器&#xff08;以下简称继电器&#xff09;适用于交流电压至660V或更高的TN、TT、和IT系统&#xff0c;频率为50Hz。通过零序电流互感器检测出超过整定值的零序&#xff08;剩余&#xff09;漏电电流。该继电器与分励脱扣器或失压脱扣器的断路器、交流接触器、…
阅读更多...
激活函数与其导数：神经网络中的关键元素

激活函数与其导数：神经网络中的关键元素

激活函数是神经网络中的重要组成部分&#xff0c;有力地推动了深度学习的发展。然而&#xff0c;仅仅了解和选择激活函数是不够的&#xff0c;我们还需要理解激活函数的导数。本文将详细介绍激活函数的概念、作用及其导数的重要性&#xff0c;并探究导数对神经网络训练的影响。…
阅读更多...
2016年12月13日 Go生态洞察：2016年Go用户调查与企业问卷

2016年12月13日 Go生态洞察：2016年Go用户调查与企业问卷

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…
阅读更多...
【UGUI】中Content Size Fitter)组件-使 UI 元素适应其内容的大小

【UGUI】中Content Size Fitter)组件-使 UI 元素适应其内容的大小

官方文档&#xff1a;使 UI 元素适应其内容的大小 - Unity 手册 必备组件&#xff1a;Content Size Fitter 通常&#xff0c;在使用矩形变换定位 UI 元素时&#xff0c;应手动指定其位置和大小&#xff08;可选择性地包括使用父矩形变换进行拉伸的行为&#xff09;。 但是&a…
阅读更多...
如何减少40%的Docker构建时间

如何减少40%的Docker构建时间

随着Docker的普及&#xff0c;许多公司的产品会将组件构建为Docker镜像。但随着时间的推移&#xff0c;一些镜像变得越来越大&#xff0c;对应的CI构建也变得越来越慢。 如果能在喝完一杯咖啡的时间&#xff08;不超过5分钟&#xff09;内完成构建&#xff0c;将是一个理想状态…
阅读更多...
使用Kibana让es集群形象起来

使用Kibana让es集群形象起来

部署Elasticsearch集群详细步骤参考本人&#xff1a; https://blog.csdn.net/m0_59933574/article/details/134605073?spm1001.2014.3001.5502https://blog.csdn.net/m0_59933574/article/details/134605073?spm1001.2014.3001.5502 kibana部署 es集群设备 安装软件主机名…
阅读更多...
【数据库】物理操作的一趟扫描算法机制原理，理解关系代数据与物理计划的关系，以及代价评估的应用和算法优化

【数据库】物理操作的一趟扫描算法机制原理，理解关系代数据与物理计划的关系，以及代价评估的应用和算法优化

一趟扫描算法 ​专栏内容&#xff1a; 手写数据库toadb 本专栏主要介绍如何从零开发&#xff0c;开发的步骤&#xff0c;以及开发过程中的涉及的原理&#xff0c;遇到的问题等&#xff0c;让大家能跟上并且可以一起开发&#xff0c;让每个需要的人成为参与者。 本专栏会定期更新…
阅读更多...
【OpenGauss源码学习 —— 执行算子（Merge Join 算子）】

【OpenGauss源码学习 —— 执行算子（Merge Join 算子）】

执行算子&#xff08;Merge Join 算子&#xff09; 连接算子Merge Join 算子ExecInitMergeJoin 函数MergeJoin 结构体 ExecMergeJoin 函数MergeJoinState 结构体 ExecEndMergeJoin 函数 总结 声明&#xff1a;本文的部分内容参考了他人的文章。在编写过程中&#xff0c;我们尊重…
阅读更多...
【Linux】vim-多模式的文本编辑器

【Linux】vim-多模式的文本编辑器

本篇文章内容和干货较多&#xff0c;希望对大家有所帮助&#x1f44d; 目录 一、vim的介绍 1.1 vi 与 vim的概念1.2 Vim 和 Vi 的一些对比 二、vim 模式之间的切换 2.1 进入vim2.2 [正常模式]切换到[插入模式]2.3 [插入模式]切换至[正常模式]2.4 [正常模式]切换至[底行模式…
阅读更多...
【仿写实现move函数】

【仿写实现move函数】

仿写实现move函数 一、值的类型 1.左值 描述&#xff1a;能够取地址的值成为左值 int a 10; const int b 15; int *pa &a; const int *pb &b;2.纯右值 描述&#xff1a;赤裸裸的字面值 eg(false , 3 , 12.23等) int a 13; int *p &a; //取a的地址 int …
阅读更多...
AVD黑屏

AVD黑屏

启动android studio的AVD后&#xff0c;无法开启&#xff0c;一直处于黑屏状态 【解决方案】 1.点击 Android Virtual Device Manager中avd后面的编辑按钮 2.点击Show Advanced Settings按钮 3.找到Boot option中的Cold boot并选中 4.重启AVD
阅读更多...
企业文件管理软件推荐：2023年5款国内外软件比较

企业文件管理软件推荐：2023年5款国内外软件比较

文件管理是现代企业中一项重要而不可避免的任务&#xff0c;不断增长的数据量和不断变化的管理需求使得选择适合自己企业的文件管理软件尤为重要。那么哪些企业文件管理软件值得我们关注呢&#xff1f;本文将为您介绍几款备受好评的企业文件管理软件&#xff0c;帮助您做出明智…
阅读更多...
【DevOps】一张图带你了解 DevOps 生态工具

【DevOps】一张图带你了解 DevOps 生态工具

一张图带你了解 DevOps 生态工具 ✅ 协作&#xff08;Collaborate&#xff09;&#xff1a;JIRA、Confluence 大家肯定不陌生了&#xff0c;我之前也写过利用 Jekyll 搭建个人博客的帖子。✅ 构建&#xff08;Build&#xff09;&#xff1a;常用的 SCM&#xff08;Software Con…
阅读更多...
一致性 Hash 算法 Hash 环发生偏移怎么解决

一致性 Hash 算法 Hash 环发生偏移怎么解决

本篇是对文章《一文彻底读懂一致性哈希算法》的重写&#xff0c;图文并茂&#xff0c;篇幅较长&#xff0c;欢迎阅读完提供宝贵的建议&#xff0c;一起提升文章质量。如果感觉不错不要忘记点赞、关注、转发哦。原文链接&#xff1a; 《一文彻底读懂一致性Hash 算法》 通过阅读本…
阅读更多...
4、LED闪烁

4、LED闪烁

LED亮灭 使用STC-ISP软件的延时计算器自动生成延迟子函数 #include <REGX52.H> #include <INTRINS.H>//延迟函数 void Delay500ms() //12.000MHz {unsigned char i, j, k;//_nop_()需要导入<INTRINS.H>包_nop_();i 4;j 205;k 187;do{do{while (--k);}…
阅读更多...
burp suite 2023.10 Intruder模块详解）

burp suite 2023.10 Intruder模块详解）

burp suite 2023 Intruder模块详解 Intruder 模块是Burp suite的一个重要功能&#xff0c;用于自动化攻击和对目标应用程序进行大规模的攻击测试。 其主要功能包括&#xff1a; Payloads 设置&#xff1a; 用户可以定义不同类型的 payload&#xff0c;例如字典、数字范围、定…
阅读更多...
Python 前后端分离项目Vue部署应用

Python 前后端分离项目Vue部署应用

一、视图创建 from django.http import JsonResponse from django.shortcuts import render# Create your views here. from django.views import Viewclass IndexView(View):def get(self,request):# 前后端分离 &#xff08;前端JS代码渲染数据&#xff09;return JsonRespo…
阅读更多...
用Python进行数据分析：探索性数据分析的实践与技巧（文末送书）

用Python进行数据分析：探索性数据分析的实践与技巧（文末送书）

&#x1f935;‍♂️ 个人主页&#xff1a;艾派森的个人主页 ✍&#x1f3fb;作者简介&#xff1a;Python学习者 &#x1f40b; 希望大家多多支持&#xff0c;我们一起进步&#xff01;&#x1f604; 如果文章对你有帮助的话&#xff0c; 欢迎评论 &#x1f4ac;点赞&#x1f4…
阅读更多...
Elasticsearch集群部署 head监控插件 Kibana部署 Nginx反向代理 Logstash部署

Elasticsearch集群部署 head监控插件 Kibana部署 Nginx反向代理 Logstash部署

一、组件介绍1、Elasticsearch&#xff1a;2 、Logstash3、Kibana4、Kafka&#xff1a;5、Filebeat: 二、 Elasticsearch集群部署服务器创建用户安装ES修改配置文件创建数据和日志目录设置JVM堆大小 #7.0默认为4G修改安装目录及存储目录权限系统优化&#xff08;1&#xff09;增…
阅读更多...
DGL的图数据处理管道

DGL的图数据处理管道

DGL在 dgl.data 里实现了很多常用的图数据集。它们遵循了由 dgl.data.DGLDataset 类定义的标准的数据处理管道。 DGL推荐用户将图数据处理为 dgl.data.DGLDataset 的子类。该类为导入、处理和保存图数据提供了简单而干净的解决方案。 DGL中的Dataset类 它是处理、导入以及保存…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023