【C++学习手札】模拟实现list

​

                                                      🎬慕斯主页：修仙—别有洞天

                                                       ♈️今日夜电波：リナリア—まるりとりゅうが

                                                                0:36━━━━━━️💟──────── 3:51
                                                                    🔄   ◀️   ⏸   ▶️    ☰ 

                                      💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍

目录

一、list实际的底层原理

二、list的模拟实现

         写在前面

各层封装的实现

        节点类

        迭代器类 

        list类 

list类详解 

        迭代器实现

list的修改操作

        Insert 

        erase

        swap 

        复用操作（push_back/front、pop_back/front、clear）

list的构造

        建立头节点

        构造函数

        拷贝构造和‘=’重载

        析构函数 

list的空间管理

list的访问相关

三、整体代码 

一、list实际的底层原理

        C++的STL库中的list是使用带头的双向循环链表实现的。list中存储的每个元素包含了两个指针，一个指向前一个节点，一个指向后一个节点，这样就可以方便地在list中进行插入和删除操作，这些操作的时间复杂度都是O(1)。

         大致的结构如下：​

         如多大家对于这个数据结构不太熟悉的话，不妨看看作者之前写的一篇关于带头双向循环链表的文章：🌀【数据结构】—C语言实现双向链表（超详细!） 

二、list的模拟实现

         写在前面

        list的底层虽然是带头双向循环链表，但是对于它的实际实现不只是简单的链表而已，当然了，我们肯定会有链表的数据结构。但是，这个“结构”，经过了三层的封装才得以实现，分别是：  第一层：list的节点类

                第二层：list的迭代器类

                第三层：list类

        本文目前只实现正向的迭代器，反向迭代器会在后面的文章统一vector、string、list一起实现。

各层封装的实现

         节点类

        主要是包括：对于两个双向指针的定义以及数据的定义，再是通过初始化列表对于节点的初始化。

    // List的节点类template<class T>struct ListNode{ListNode(const T& val = T())//通过初始化列表初始化值:_val(val), _pPre(nullptr), _pNext(nullptr){}ListNode<T>* _pPre;ListNode<T>* _pNext;T _val;};

        迭代器类 

         迭代器实际上是对于指针进行操作，因此我们实例化并且重新命名了节点类的指针PNode,由于迭代器分为是否常量正向迭代器，对此我们额外定义了两个模板参数Ref、Ptr用于控制其中重载运算符 T& operator*() 和 T* operator->()。后面的list类中会有体现。在迭代器中，其中，operator*和operator->返回指向节点的指针，operator++和operator--实现前后缀++/--运算符，operator==和operator!=用来比较两个迭代器是否指向同一个节点。

    //List的迭代器类template<class T, class Ref, class Ptr>class ListIterator{typedef ListNode<T>* PNode;typedef ListIterator<T, Ref, Ptr> Self;public:ListIterator(PNode pNode = nullptr):_pNode(pNode){}ListIterator(const Self& l):_pNode(l._pNode){}T& operator*(){return _pNode->_val;}T* operator->(){return &*this;}Self& operator++(){_pNode = _pNode->_pNext;return *this;}Self operator++(int){Self temp(*this);_pNode = _pNode->_pNext;return temp;}Self& operator--(){_pNode = _pNode->_pPre;return *this;}Self& operator--(int){Self temp(*this);_pNode = _pNode->_pPre;return temp;}bool operator!=(const Self& l){return _pNode != l._pNode;}bool operator==(const Self& l){return !(*this != l);}private:PNode _pNode;};

        list类 

        这里先给出主要的封装，具体的实现后面详解。可以看到我们又对于节点类进行了实例化并且重新命名，并且定义了一个数据变量。下面是重点了：我们对于迭代器类也进行了实例化并且重新命名，特别是对于上面我们所提到的Ref和Ptr是有做变动的注意看：对于是否常量正向迭代器分别做出了如下定义：T&, T*和const T&, const T*。这里所这的一些变动也是为了后续简化代码，避免我们因为动静态多一份代码。

        请结合上面我们迭代器类中我们所提到的operator==和operator!=理解。

class list{typedef ListNode<T> Node;typedef Node* PNode;public:typedef ListIterator<T, T&, T*> iterator;//普通迭代器重命名typedef ListIterator<T, const T&, const T*> const_iterator;//静态迭代器重命名public://...private:PNode _pHead;};

list类详解 

        在C++中我们通常会进行各类函数的复用，以减少代码量和增加可读性。对此，我们尽量做到复用。

         迭代器实现

        返回头以及尾的迭代器，注意区分动静态 。

        // List Iteratoriterator begin(){return iterator(_pHead->_pNext);}iterator end(){return iterator(_pHead);}const_iterator begin()const{return const_iterator(_pHead->_pNext);}const_iterator end()const{return const_iterator(_pHead);}

 list的修改操作

        Insert 

         实现在pos位置前插入值为val的节点，开辟空间->保存原位置节点->新节点的前指针指向原节点的前一个节点->后节点指向原节点->该边原节点的前一个节点的后指针指向，指向新节点->原节点的前指针指向新节点->返回性节点的迭代器。

// 在pos位置前插入值为val的节点iterator insert(iterator pos, const T& val){PNode pNewNode = new Node(val);PNode pCur = pos._pNode;pNewNode->_pPre = pCur->_pPre;pNewNode->_pNext = pCur;pNewNode->_pPre->_pNext = pNewNode;pCur->_pPre = pNewNode;return iterator(pNewNode);}

         erase

         删除pos位置的节点，返回该节点的下一个位置，保存删除j节点，保存原节点的下一个节点（用于返回）->一些列删除解链接操作->返回原节点的下一个节点的迭代器

        // 删除pos位置的节点，返回该节点的下一个位置iterator erase(iterator pos){PNode pDel = pos._pNode;PNode pRet = pDel->_pNext;pDel->_pPre->_pNext = pDel->_pNext;pDel->_pNext->_pPre = pDel->_pPre;delete pDel;return iterator(pRet);}

        swap 

        void swap(list<T>& l){pNode tmp = _pHead;_pHead = l._pHead;l._pHead = tmp;}

         复用操作（push_back/front、pop_back/front、clear）

        void push_back(const T& val){ insert(end(), val);}void pop_back(){ erase(--end()); }void push_front(const T& val) { insert(begin(), val); }void pop_front() { erase(begin());}void clear(){iterator p = begin();while (p != end()){p = erase(p);}_pHead->_pPre = _pHead;_pHead->_pNext = _pHead;}

 list的构造

         建立头节点

        因为我们在构造、 拷贝等很多的场景中都会用到对于头结点的初始化，对此额外写一个函数用于减少代码量。

        void CreateHead(){_pHead = new Node;_pHead->_pPre = _pHead;_pHead->_pNext = _pHead;}

         构造函数

        实现无参、含参初始化、迭代器构造。

        // List的构造list(){CreateHead();}list(int n, const T& value = T()){CreateHead();for (int i = 0; i < n; ++i){push_back(value);}}template <class Iterator>list(Iterator first, Iterator last){CreateHead();while (first != last){push_back(*first);++first;}}

        拷贝构造和‘=’重载

        list(const list<T>& l){CreateHead();list<T> temp(l.begin(), l.end());this->swap(temp);}list<T>& operator=(const list<T> l){this->swap(l);return *this;}

        析构函数 

        ~list(){clear();delete _pHead;_pHead = nullptr;}

 list的空间管理

        size_t size()const{size_t size = 0;ListNode* p = _pHead->_pNext;while (p != _pHead){size++;p = p->_pNext;}return size;}bool empty()const{return size() == 0;}

list的访问相关

        主要还是要区分是否为动静态相关。

        T& front(){assert(!empty());return _pHead->_pNext->_val;}const T& front()const{assert(!empty());return _pHead->_pNext->_val;}T& back(){assert(!empty());return _pHead->_pPre->_val;}const T& back()const{assert(!empty());return _pHead->_pPre->_val;}

三、整体代码 

#pragma once
#include<iostream>
#include<assert.h>using namespace std;namespace lt
{// List的节点类template<class T>struct ListNode{ListNode(const T& val = T())//通过初始化列表初始化值:_val(val), _pPre(nullptr), _pNext(nullptr){}ListNode<T>* _pPre;ListNode<T>* _pNext;T _val;};//List的迭代器类template<class T, class Ref, class Ptr>class ListIterator{typedef ListNode<T>* PNode;typedef ListIterator<T, Ref, Ptr> Self;public:ListIterator(PNode pNode = nullptr):_pNode(pNode){}ListIterator(const Self& l):_pNode(l._pNode){}T& operator*(){return _pNode->_val;}T* operator->(){return &*this;}Self& operator++(){_pNode = _pNode->_pNext;return *this;}Self operator++(int){Self temp(*this);_pNode = _pNode->_pNext;return temp;}Self& operator--(){_pNode = _pNode->_pPre;return *this;}Self& operator--(int){Self temp(*this);_pNode = _pNode->_pPre;return temp;}bool operator!=(const Self& l){return _pNode != l._pNode;}bool operator==(const Self& l){return !(*this != l);}private:PNode _pNode;};//list类template<class T>class list{typedef ListNode<T> Node;typedef Node* PNode;public:typedef ListIterator<T, T&, T*> iterator;//普通迭代器重命名typedef ListIterator<T, const T&, const T*> const_iterator;//静态迭代器重命名public:///// List的构造list(){CreateHead();}list(int n, const T& value = T()){CreateHead();for (int i = 0; i < n; ++i){push_back(value);}}template <class Iterator>list(Iterator first, Iterator last){CreateHead();while (first != last){push_back(*first);++first;}}list(const list<T>& l){CreateHead();list<T> temp(l.begin(), l.end());this->swap(temp);}list<T>& operator=(const list<T> l){this->swap(l);return *this;}~list(){clear();delete _pHead;_pHead = nullptr;}///// List Iteratoriterator begin(){return iterator(_pHead->_pNext);}iterator end(){return iterator(_pHead);}const_iterator begin()const{return const_iterator(_pHead->_pNext);}const_iterator end()const{return const_iterator(_pHead);}///// List Capacitysize_t size()const{size_t size = 0;ListNode* p = _pHead->_pNext;while (p != _pHead){size++;p = p->_pNext;}return size;}bool empty()const{return size() == 0;}// List AccessT& front(){assert(!empty());return _pHead->_pNext->_val;}const T& front()const{assert(!empty());return _pHead->_pNext->_val;}T& back(){assert(!empty());return _pHead->_pPre->_val;}const T& back()const{assert(!empty());return _pHead->_pPre->_val;}// List Modifyvoid push_back(const T& val){ insert(end(), val);}void pop_back(){ erase(--end()); }void push_front(const T& val) { insert(begin(), val); }void pop_front() { erase(begin());}// 在pos位置前插入值为val的节点iterator insert(iterator pos, const T& val){PNode pNewNode = new Node(val);PNode pCur = pos._pNode;pNewNode->_pPre = pCur->_pPre;pNewNode->_pNext = pCur;pNewNode->_pPre->_pNext = pNewNode;pCur->_pPre = pNewNode;return iterator(pNewNode);}// 删除pos位置的节点，返回该节点的下一个位置iterator erase(iterator pos){PNode pDel = pos._pNode;PNode pRet = pDel->_pNext;pDel->_pPre->_pNext = pDel->_pNext;pDel->_pNext->_pPre = pDel->_pPre;delete pDel;return iterator(pRet);}void clear(){iterator p = begin();while (p != end()){p = erase(p);}_pHead->_pPre = _pHead;_pHead->_pNext = _pHead;}void swap(list<T>& l){pNode tmp = _pHead;_pHead = l._pHead;l._pHead = tmp;}private:void CreateHead(){_pHead = new Node;_pHead->_pPre = _pHead;_pHead->_pNext = _pHead;}PNode _pHead;};
};

                        感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！ 

                                       

                                                                         给个三连再走嘛~  

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【面试送分题！“商品分类浏览”如何测试？】

【面试送分题！“商品分类浏览”如何测试？】

电商项目无论是工作中&#xff0c;还是面试中&#xff0c;都是一个高频出现的词。 面试官非常热衷提问关于电商项目的问题。例如商品分类怎么测试&#xff1f;购物车怎么测试&#xff1f;订单怎么测试&#xff1f;优惠券怎么测试&#xff1f;支付怎么测试&#xff1f;等等。 …
阅读更多...
搭配：基于OpenCV的边缘检测实战

搭配：基于OpenCV的边缘检测实战

引言 计算机中的目标检测与人类识别物体的方式相似。作为人类&#xff0c;我们可以分辨出狗的形象&#xff0c;因为狗的特征是独特的。尾巴、形状、鼻子、舌头等特征综合在一起&#xff0c;帮助我们把狗和牛区分开来。 同样&#xff0c;计算机能够通过检测与估计物体的结构和性…
阅读更多...
【华为数通HCIP | 网络工程师】821-IGP高频题、易错题之OSPF（1）

【华为数通HCIP | 网络工程师】821-IGP高频题、易错题之OSPF（1）

个人名片&#xff1a; &#x1f43c;作者简介&#xff1a;一名大三在校生&#xff0c;喜欢AI编程&#x1f38b; &#x1f43b;‍❄️个人主页&#x1f947;&#xff1a;落798. &#x1f43c;个人WeChat&#xff1a;hmmwx53 &#x1f54a;️系列专栏&#xff1a;&#x1f5bc;️…
阅读更多...
【Spring进阶系列丨第四篇】学习Spring中的Bean管理(基于xml配置)

【Spring进阶系列丨第四篇】学习Spring中的Bean管理(基于xml配置)

前言 在之前的学习中我们知道&#xff0c;容器是一个空间的概念&#xff0c;一般理解为可盛放物体的地方。在Spring容器通常理解为BeanFactory或者ApplicationContext。我们知道spring的IOC容器能够帮我们创建对象&#xff0c;对象交给spring管理之后我们就不用手动去new对象。…
阅读更多...
【鸿蒙应用ArkTS开发系列】- 云开发入门实战二 实现省市地区三级联动地址选择器组件（上）

【鸿蒙应用ArkTS开发系列】- 云开发入门实战二 实现省市地区三级联动地址选择器组件（上）

目录 概述 云数据库开发 一、创建云数据库的对象类型。 二、预置数据&#xff08;为对象类型添加数据条目&#xff09;。 三、部署云数据库 云函数实现业务逻辑 一、创建云函数 二、云函数目录讲解 三、创建resources目录 四、获取云端凭据 五、导出之前创建的元数据…
阅读更多...
数据分析基础之《matplotlib（2）—折线图》

数据分析基础之《matplotlib（2）—折线图》

一、折线图绘制与保存图片 1、matplotlib.pyplot模块 matplotlib.pyplot包含了一系列类似于matlab的画图函数。它的函数作用于当前图形&#xff08;figure&#xff09;的当前坐标系&#xff08;axes&#xff09; import matplotlib.pyplot as plt 2、折线图绘制与显示 展示城…
阅读更多...
NVM得介绍和详细使用教程

NVM得介绍和详细使用教程

NVM​​​​​​​&#xff08;Node Version Manager&#xff09;是一个用于管理多个Node.js版本的工具。它允许您在同一台计算机上轻松地切换和管理不同的Node.js版本。以下是NVM的介绍和详细使用教程&#xff1a; 安装NVM&#xff1a; 首先&#xff0c;您需要在计算机上安装N…
阅读更多...
C++学习之路（一）什么是C++？如何循序渐进的学习C++？【纯干货】

C++学习之路（一）什么是C++？如何循序渐进的学习C++？【纯干货】

C是一种高级编程语言&#xff0c;是对C语言的扩展和增强。它在C语言的基础上添加了面向对象编程&#xff08;OOP&#xff09;的特性&#xff0c;使得开发者能够更加灵活和高效地编写代码。 C的名字中的“”符号表示在C语言的基础上向前发展一步&#xff0c;即“加加”&#x…
阅读更多...
Linux(Centos)上使用crontab实现定时任务(定时执行脚本)

Linux(Centos)上使用crontab实现定时任务(定时执行脚本)

场景 Windows中通过bat定时执行命令和mysqldump实现数据库备份&#xff1a; Windows中通过bat定时执行命令和mysqldump实现数据库备份_mysqldump bat-CSDN博客 上面讲windows中使用bat实现定时任务的方式&#xff0c;如果是在linux上可以通过crontab实现。 cron是服务名称。…
阅读更多...
Python“牵手”京东商品详情接口运营场景，京东商品详情接口调用指南

Python“牵手”京东商品详情接口运营场景，京东商品详情接口调用指南

京东商品详情接口是一种程序化的接口&#xff0c;通过这个接口&#xff0c;商家或开发者可以使用自己的编程技能&#xff0c;获取京东平台上的商品详细信息。这个接口允许商家根据自身的需求&#xff0c;获取商品的标题、价格、促销价、优惠券、库存、销量、详情图片、SKU属性、…
阅读更多...
小叶子钢琴智能陪练 助力打牢钢琴基础

小叶子钢琴智能陪练 助力打牢钢琴基础

孩子在练琴过程中&#xff0c;经常会出现错音错节奏&#xff0c;为了能够帮助她更高效的练琴&#xff0c;最近开始使用智能钢琴陪练工具——小叶子钢琴智能陪练。 身边也有很多朋友在用这款应用&#xff0c;它比较知名的功能就是三大练琴模式&#xff0c;也就是识谱模式、提升…
阅读更多...
揭秘周杰伦《最伟大的作品》MV，绝美UI配色方案竟然藏在这里

揭秘周杰伦《最伟大的作品》MV，绝美UI配色方案竟然藏在这里

色彩在UI设计的基本框架中占据着举足轻重的位置。实际上&#xff0c;精心挑选和组合的色彩配色&#xff0c;往往就是UI设计成功的不二法门。在打造出一个实用的UI配色方案过程中&#xff0c;我们需要有坚实的色彩理论知识&#xff0c;同时还需要擅于从生活中观察和提取灵感。以…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023