C++ list模拟实现

list模拟实现代码：

namespace djx
{template<class T>struct list_node{T _data;list_node<T>* _prev;list_node<T>* _next;list_node(const T& x = T()):_data(x),_prev(nullptr),_next(nullptr){}};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){return _node != s._node;}bool operator==(const self& s){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_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(const list<T>& lt){empty_init();for (auto e : lt){push_back(e);}}void swap(list<T>& lt){std::swap(_head, lt._head);std::swap(_size, lt._size);}list<T>& operator=(list<T> lt){swap(lt);return *this;}~list(){clear();delete _head;_head = nullptr;}void clear(){iterator it = begin();while (it != end()){it = erase(it);}}void push_back(const T& x){insert(end(), x);}void push_front(const T& x){insert(begin(), x);}void pop_back(){erase(--end());}void pop_front(){erase(begin());}iterator insert(iterator pos, const T& x){Node* cur = pos._node;Node* newnode = new Node(x);Node* prev = cur->_prev;prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;_size++;return newnode;}iterator erase(iterator pos){Node* cur = pos._node;Node* next = cur->_next;Node* prev = cur->_prev;delete cur;prev->_next = next;next->_prev = prev;_size--;return next;}size_t size(){return _size;}private:Node* _head;size_t _size;};
}

源码中的list实现为带头双向链表

 

list类的对象有两个成员：指向头结点的指针_head，统计数据个数的_size

在模拟实现list之前，需要先模拟实现结点类，迭代器类

结点类：三个成员，_data _prev _next，实现成struct（也是类，不过与class不同的是，它的成员都是公开的，都可以在类外访问），因为这三个成员，在迭代器类中都要使用访问，设it是迭代器，*it就会返回结点中值(_data)的引用，it++（要访问结点中的_next) ， it--（要访问结点中的_prev)

    template<class T>struct list_node{T _data;list_node<T>* _prev;list_node<T>* _next;list_node(const T& x = T())//x是匿名对象的引用，const延长了匿名对象的生命周期，x销毁，匿名对象才销毁，匿名对象会调用它的构造函数，完成初始化:_data(x),_prev(nullptr),_next(nullptr){}};

要写构造函数：list类中的push_back插入数据时，需要new一个结点，并传数值

                         调用构造函数时，若是直接使用编译器生成的默认构造函数，则无法传参

构造函数的参数设计成缺省参数：有传实参过来就使用此值，没有传参过来就用匿名对象去拷贝构造_data，使用匿名对象去拷贝构造_data的情形：list类中的无参构造函数-->让list中的成员变量_head指向一个new出来的头结点，头结点中不存储任何有效数据，故而new时无需传参

迭代器类：一个成员 _node（结点的指针）

设计成struct：在list类中设计insert和erase时，传参给它们的是iterator迭代器，我们要使用迭代器中的成员变量（结点的指针）即要访问迭代器中的成员，那么设计成struct会比设计成class类方便不少

list的迭代器与vector,string类不同，在模拟实现vector和string的迭代器时，它们可以用原生指针来实现，因为完美契合原生指针的行为，但是模拟实现list的迭代器时，它必须设计成一个类，是对原生指针的封装，原因：

若是list的迭代器就用原生指针来实现，那么*it（it是一个迭代器）得到的不是数据，而是结点

it++ 不能走向下一个数据，故而需要对原生指针进行封装，让*it得到数据，it++，走向下一个数据

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)//要写带参的构造，因为在list类中实现begin()时，返回值的类型是迭代器，但是我们返回的可以是结点的指针，单参数的构造函数支持隐式类型转换，也可以是迭代器，但是此迭代器中的成员变量（结点的指针）需要和第一个结点的指针一样:_node(node){}Ref operator*()//Ref可以是T&（普通迭代器） const T& （const迭代器）{return _node->_data;}Ptr operator->()Ptr可以是T* (普通迭代器） const T* (const迭代器）{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){return _node != s._node;}bool operator==(const self& s){return _node == s._node;}};

迭代器有非const对象调用的，也有const对象调用的，二者的区别仅仅是能否修改的问题，*迭代器返回的是数据的引用，const对象调用的迭代器返回的也是数据的引用，但是const修饰的

迭代器-> 返回的是数据的地址，const对象调用的迭代器返回的是const修饰的数据地址

(迭代器可以看作是模拟原生指针的行为，若是数据为自定义类型，那么迭代器->就可以访问到自定义类型对象中的成员，实际上看成是原生指针的迭代器-> 无法做到，但是对原生指针封装而出现的迭代器可以做到，只要迭代器->返回的是数据的指针，那么有了自定义类型对象指针，不就可以访问它里面的成员了吗）

综上来看，我们只需要写一份迭代器类的模板，根据实例化参数的不同，生成不同的迭代器

迭代器需要三个模板参数：T（迭代器类中的成员变量是结点的指针，结点实例化需要）

模板参数 Ref  : 迭代器类中重载*运算符所用，重载*运算符的函数要返回数据的引用，而若是const对象的迭代器解引用，就要用const去修饰返回值

模板参数Ptr ：迭代器类中重载->运算符所用，重载->运算符的函数返回数据的指针，而若是const对象的迭代器->，也要用const去修饰返回值

那么在list类中，设计普通迭代器，const对象调用的迭代器时，就可以用迭代器类的模板，实例化参数不同就会是完全不同的类型，普通迭代器用迭代器类的模板实例化，传参 T   T&   T*

const对象调用的迭代器用迭代器类的模板实例化，传参 T  const T&   const T*

构造函数：

1 无参的构造

    让list对象中的成员变量_head指向一个头指针（双向循环）

    参照源码list的实现：

 

        void empty_init(){_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}list(){empty_init();}

2 拷贝构造（深拷贝）

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

析构函数：

        ~list(){clear();delete _head;//释放头结点_head = nullptr;}void clear()//清除数据{iterator it = begin();while (it != end()){it = erase(it);}}

赋值重载：

        void swap(list<T>& lt){std::swap(_head, lt._head);std::swap(_size, lt._size);}list<T>& operator=(list<T> lt)///lt是实参的深拷贝，lt销毁会释放掉原本由*this申请的空间{swap(lt);//交换*this和ltreturn *this;}

迭代器：

        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_iterator begin()const{return _head->_next;}const_iterator end()const{return _head;}

测试1：

void test1()
{djx::list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);djx::list<int>:: iterator it = lt.begin();while (it != lt.end()){*it += 20;cout << *it << " ";it++;}cout << endl;for (auto e : lt){cout << e << " ";}cout << endl;
}

测试2：

void test2()
{djx::list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_back(5);djx::list<int> lt1(lt);//拷贝构造for (auto e : lt){cout << e << " ";}cout << endl;for (auto e : lt1){cout << e << " ";}cout << endl;djx::list<int> lt2;lt2.push_back(100);lt2.push_back(200);lt2.push_back(300);lt2.push_back(400);lt2.push_back(500);lt1 = lt2;//赋值重载for (auto e : lt1){cout << e << " ";}cout << endl;for (auto e : lt2){cout << e << " ";}cout << endl;}

 

 

插入：

 1 push_back

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

2 push_front

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

3 insert

        iterator insert(iterator pos, const T& x){Node* cur = pos._node;//当前节点的指针Node* newnode = new Node(x);Node* prev = cur->_prev;prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;_size++;return newnode;//单参数的构造函数支持隐式类型转换//或者写成：iterator(newnode)}

删除：

1 pop_back

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

2 pop_front

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

3 erase

        iterator erase(iterator pos){Node* cur = pos._node;Node* next = cur->_next;Node* prev = cur->_prev;delete cur;prev->_next = next;next->_prev = prev;_size--;return next;//返回下一个数据的地址}

测试3：

struct AA
{AA(int a1 = 0, int a2 = 0):_a1(a1), _a2(a2){}int _a1;int _a2;
};void test3()
{djx::list<AA> lt;lt.push_back(AA(1, 1));lt.push_back(AA(2, 2));lt.push_back(AA(3, 3));djx::list<AA>::iterator it = lt.begin();while (it != lt.end()){//cout << (*it)._a1 << " "<<(*it)._a2<<endl;cout << it->_a1 << " " << it->_a2 << endl;it++;}cout << endl;
}

题外：

 设计一个打印函数，打印任意list对象

template<typename T>//不可以用class
void print_list(const djx:: list<T>& lt)
{//list<T>未实例化的类模板，编译器不能去它里面去找//编译器就无法list<T>::const_iterator是内嵌类型，还是静态成员变量//前面加一个typename就是告诉编译器，这里是一个类型，等list<T>实例化，再去类里面找typename djx::list<T>::const_iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";it++;}cout << endl;
}

打印任意容器

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

测试4：

void test4()
{djx::list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);print_list(lt);
}

测试5：

void test5()
{djx::list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);print_container(lt);djx::list<string> lt1;lt1.push_back("1111111111111");lt1.push_back("1111111111111");lt1.push_back("1111111111111");lt1.push_back("1111111111111");lt1.push_back("1111111111111");//print_list(lt1);print_container(lt1);vector<string> v;v.push_back("222222222222222222222");v.push_back("222222222222222222222");v.push_back("222222222222222222222");v.push_back("222222222222222222222");print_container(v);}

 

 

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

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

相关文章

Linux 云服务器挂载数据盘

Linux 云服务器挂载数据盘

1、检查linux服务器磁盘情况 df -h 可以看到无磁盘挂载信息。 2、查看待挂载磁盘信息 fdisk -l 可以看到40G系统盘、50G数据盘&#xff08;盘符&#xff1a;/dev/vdb&#xff09; 3、对数据盘分区 fdisk /dev/vdb 根据提示&#xff0c;依次输入“n”&#xff0c;“p”“1…
阅读更多...
今日举办亚马逊云科技re:Inforce大会：结合生成式AI安全最新趋势，解决企业新挑战

今日举办亚马逊云科技re:Inforce大会：结合生成式AI安全最新趋势，解决企业新挑战

2023年&#xff0c;生成式AI带来了无数的创新&#xff0c;并将会在行业应用中产生更多的新能力、新场景。与此同时&#xff0c;关于生成式AI的风险管控成为各方关注焦点&#xff0c;数据隐私、合规保护、防欺诈等&#xff0c;已成为生成式AI时代的安全合规的新话题。 随着云上业…
阅读更多...
Java【手撕滑动窗口】LeetCode 3. “无重复字符的最长子串“, 图文详解思路分析 + 代码

Java【手撕滑动窗口】LeetCode 3. “无重复字符的最长子串“, 图文详解思路分析 + 代码

文章目录 前言一、长度最小子数组1, 题目2, 思路分析3, 代码 前言 各位读者好, 我是小陈, 这是我的个人主页, 希望我的专栏能够帮助到你: &#x1f4d5; JavaSE基础: 基础语法, 类和对象, 封装继承多态, 接口, 综合小练习图书管理系统等 &#x1f4d7; Java数据结构: 顺序表, 链…
阅读更多...
Nacos配置管理

Nacos配置管理

统一配置管理 当微服务部署的实例越来越多&#xff0c;达到数十、数百时&#xff0c;逐个修改微服务配置就会让人抓狂&#xff0c;而且很容易出错。我们需要一种统一配置管理方案&#xff0c;可以集中管理所有实例的配置。 Nacos一方面可以将配置集中管理&#xff0c;另一方可…
阅读更多...
Python钢筋混凝土结构计算.pdf-已知弯矩确定混凝土梁截面尺寸

Python钢筋混凝土结构计算.pdf-已知弯矩确定混凝土梁截面尺寸

计算原理 确定混凝土梁截面的合理尺寸通常需要考虑弯矩、受力要求和约束条件等多个因素。以下是一种常见的计算公式&#xff0c;用于基于已知弯矩确定混凝土梁截面的合理尺寸&#xff1a; 请注意&#xff0c;以上公式仅提供了一种常见的计算方法&#xff0c;并且具体的规范和设…
阅读更多...
Python 实战之ChatGPT + Python 实现全自动数据处理/可视化详解

Python 实战之ChatGPT + Python 实现全自动数据处理/可视化详解

本文目录 一、引言 二、成果演示——口述式数据可视化 三、远原理述 四、实现过程 &#xff08;一&#xff09;环境配置 &#xff08;二&#xff09;申请OpenAI账号 &#xff08;一&#xff09;调用ChatGPT API &#xff08;二&#xff09;设计AI身份&#xff0c;全自动处理数据…
阅读更多...
【附安装包】Multisim 14.0安装教程|电子电路

【附安装包】Multisim 14.0安装教程|电子电路

软件下载 软件&#xff1a;Multisim版本&#xff1a;14.0语言&#xff1a;简体中文大小&#xff1a;649.68M安装环境&#xff1a;Win11/Win10/Win8/Win7硬件要求&#xff1a;CPU2.5GHz 内存4G(或更高&#xff09;下载通道①百度网盘丨64位下载链接&#xff1a;https://pan.bai…
阅读更多...
jdk17+springboot使用webservice，踩坑记录

jdk17+springboot使用webservice，踩坑记录

这几天wms对接lbpm系统&#xff0c;给我的接口是webservice的&#xff0c;老实说&#xff0c;这个技术很早&#xff0c;奈何人家只支持这个。 环境说明&#xff1a;JDK17 springboot2.6.6。网上很多教程是基于jdk8的&#xff0c;所以很多在17上面跑不起来。折腾两天&#xff0c…
阅读更多...
OJ练习第154题——到家的最少跳跃次数

OJ练习第154题——到家的最少跳跃次数

到家的最少跳跃次数 力扣链接&#xff1a;1654. 到家的最少跳跃次数 题目描述 有一只跳蚤的家在数轴上的位置 x 处。请你帮助它从位置 0 出发&#xff0c;到达它的家。 跳蚤跳跃的规则如下&#xff1a; 它可以 往前 跳恰好 a 个位置&#xff08;即往右跳&#xff09;。 它…
阅读更多...
【Linux】进程概念

【Linux】进程概念

文章目录 一.进程1.概念2.描述进程——pcb3.pcb&#xff08;task_struct&#xff09;内容分类4.查看进程&#xff08;1&#xff09;通过系统调用查看&#xff08;2&#xff09;通过ps命令查看 二.通过系统调用获取进程的PID和PPID三.通过系统调用创建子进程fork()1.fork函数创建…
阅读更多...
8.31作业

8.31作业

阅读更多...
53. 最大子数组和

53. 最大子数组和

题目 给你一个整数数组 nums &#xff0c;请你找出一个具有最大和的连续子数组&#xff08;子数组最少包含一个元素&#xff09;&#xff0c;返回其最大和。子数组 是数组中的一个连续部分示例 示例 1&#xff1a; 输入&#xff1a;nums [-2,1,-3,4,-1,2,1,-5,4] 输出&#…
阅读更多...
docker拉取镜像报错

docker拉取镜像报错

#拉取镜像报错如下 failed to register layer: exit status 22: unpigz: abort: zlib version less than 1.2.3这个是因为pigz的bug github链接。 复现&#xff1a; # 查看pigz版本 ~]# pigz version zlib version less than 1.2.3 #但是实际上我的zlib版本是大于1.2.3的&am…
阅读更多...
小游戏分发平台如何以技术拓流？

小游戏分发平台如何以技术拓流？

2023年&#xff0c;小游戏的发展将受到多方面的影响&#xff0c;例如新技术的引入、参与小游戏的新玩家以及游戏市场的激烈竞争等。首先&#xff0c;新技术如虚拟现实&#xff08;VR&#xff09;、增强现实&#xff08;AR&#xff09;和机器人技术都可以带来新颖的游戏体验。其…
阅读更多...
spring打入filter内存马+冰蝎成功

spring打入filter内存马+冰蝎成功

环境&#xff1a; springboot版本2.4.5 <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.4.5</version><relativePath/> <!-- lookup parent from r…
阅读更多...
thinkphp6如何将需要记录的日志单独记录到一个日志中

thinkphp6如何将需要记录的日志单独记录到一个日志中

如何将需要记录的日志单独记录到一个日志中 有时候需要将具体情况的日志统一记录到单一的类目中方便查看。比如支付日志&#xff0c;回调日志。可以使用通道解决方法。 1.日志通道channel 将配置不同的日志通道&#xff0c;将不同的日志记录到不同的日志中 使用方法&#xf…
阅读更多...
浏览器从输入 url 到显示网页的全过程

浏览器从输入 url 到显示网页的全过程

浏览器从输入 url 到显示网页的全过程 浏览器从输入 url 到显示网页的全过程DNS&#xff08;Domain Name System&#xff09;解析 浏览器从输入 url 到显示网页的全过程 当你在浏览器中输入一个URL并按下Enter键&#xff0c;以下是浏览器为显示网页所执行的一系列步骤&#xf…
阅读更多...
spring小记

spring小记

Spring是轻量级的开源的javaEE框架目的&#xff1a;解决企业应用开发的复杂性 Spring有两个核心部分&#xff1a;IOC和AOP <1>IOC&#xff1a;控制反转&#xff0c;把创建的对象过程交给Spring进行管理 <2>AOP&#xff1a;面向切面&#xff0c;不修改源代码进行…
阅读更多...
为什么建议同时学多门编程语言

为什么建议同时学多门编程语言

晨读一本名叫《4点起床》的书&#xff0c;书中有一段描述与最近学习编制语言时自己的感受完全一致。算是一个小经验&#xff0c;分享给大家。 书中有一章的标题为《同时学六国语言记起来比较快》&#xff0c;其中有两段描述如下&#xff1a; 为什么我推荐大家同时学不同的语言…
阅读更多...
大数据-玩转数据-Flink 水印

大数据-玩转数据-Flink 水印

一、Flink 中的水印 在Flink的流式操作中, 会涉及不同的时间概念&#xff1a; 1.1 处理时间 是指的执行操作的各个设备的时间&#xff0c;对于运行在处理时间上的流程序, 所有的基于时间的操作(比如时间窗口)都是使用的设备时钟。比如, 一个长度为1个小时的窗口将会包含设备…
阅读更多...
最新文章

Copyright @ 2022~2023