C++ STL专题 list的底层实现

news2024/9/24 7:19:59

目录

1.模拟实现list

2.节点模板讲解

3.迭代器模板讲解

3.1为什么template 有三个类型参数

(1).class T

(2).class ref

(3).class ptr

3.2  *重载

3.3 ->重载

3.4 前置++和++后置的重载

3.5 前置--和--后置的重载

3.6 ==和!=的重载

4. list模板讲解

4.1 begin()函数

4.2 end()函数

4.3 空初始化函数

4.4 深拷贝函数

4.5 交换函数

4.6 赋值运算符operator=的实现

4.7 析构函数和clear()函数

4.8 push_back函数

4.9 插入函数

4.10 push_front函数

4.11 erase函数

4.12 头删和尾删

4.13 size函数

3.14 empty函数

1.模拟实现list

分别定义了三个类模板

分别是节点模板，迭代器模板，list模板

template <class T>
class list_node
{
public:
    T _data;
    list_node<T>* _next;
    list_node<T>* _prev;

    list_node(const T& data = T())
        : _data(data), _next(nullptr), _prev(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;
};
template <class T>
class list
{
    typedef list_node<T> Node;

public:


private:
    Node* _head;
    size_t _size;
};

2.节点模板讲解

源码：
 

template <class T>
class list_node
{
public:
    T _data;
    list_node<T>* _next;
    list_node<T>* _prev;

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

(1).定义值域_data，用于存放数值，在定义指向下一个节点和上一个节点的指针。

(2).默认构造函数，可用于初始化，赋值等等。

3.迭代器模板讲解

源码：

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

3.1为什么template <class T, class ref, class ptr>有三个类型参数

(1).class T

T通常用于表示迭代器所指的数据类型。在list中，T是链表节点中存储的数据类型。例如：如果此链表用于存储整数，那么T就是int；如果链表用于存储字符串，则T就是string。

(2).class ref

ref用于定义解引用迭代器时返回的类型，这允许迭代器解引用时的行为。

在这个代码中，ref被用作operator*()的返回类型，他返回_node->_data的一个引用。这意味着ref应该是对T类型的引用类型，通常是T&。

(3).class ptr

ptr用于定义迭代器箭头操作符operator->()的返回类型。他返回_node->_data的地址，这意味着ptr应该是一个指针类型，，通常是T*。

这三个类型参数T，ref，ptr提供了对迭代器行为的精细度控制，使得迭代器模板能够更加灵活和通用地应对不同场景和数据类型。

3.2  *重载

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

(1).*为解引用，要获取值，则返回这个值的引用即可。(ref被用作operator*()的返回类型)

3.3 ->重载

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

(1). ->为获取地址，获取地址，就返回地址即可。(ref被用作operator*()的返回类型)

3.4 前置++和++后置的重载

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

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

(1).前置++中，由于是先自加再赋值，所以直接将_node=_node->_next即可，然后返回*this。

(1).++后置中，由于是先赋值再自加，所以要先把改变之前的值保持在tmp中，再对_node作改变，最后返回的是tmp。

3.5 前置--和--后置的重载

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

(1).前置--中，由于是先自减再赋值，所以直接将_node=_node->_prev即可，然后返回*this。

(2).--后置中，由于是先赋值再自减，所以要先把改变之前的值保持在tmp中，再对_node作改变，最后返回的是tmp。

3.6 ==和!=的重载

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

(1) ==和!=中，直接判断s与_node 是否相等即可。

(2)注意：
        这两个运算符通常应该一起被重载，以保持它们之间的一致性。

        它们被声明为const成员函数，因为它们不修改_node成员。

        

4. list模板讲解

源码：

template <class T>
class list
{
    typedef list_node<T> Node;

public:
    // typedef list_iterator<T> iterator;
    // typedef list_const_iterator<T> const_iterator;

    typedef list_iterator<T, T&, T*> iterator;
    typedef list_iterator<T, const T&, const T*> const_iterator;

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

    iterator end()
    {
        iterator it(_head);
        return it;
    }

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

    const_iterator end() const
    {
        iterator it(_head);
        return it;
    }

    void empty_init()
    {
        _head = new Node(T());
        _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);
        }
    }

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

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

    void clear()
    {
        auto it = begin();
        while (it != end())
        {
            it = erase(it); // 返回下一个的迭代器
        }
    }

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

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

        tail->_next = newnode;
        newnode->_prev = tail;
        newnode->_next = _head;
        _head->_prev = newnode;
        _size++;

        // insert(end(),x);
    }

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

    // 在pos之前插入
    void 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++;
    }

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

    size_t size() const
    {
        return _size;
    }

    bool empty()
    {
        return _size == 0;
    }

private:
    Node* _head;
    size_t _size;
};

重命名：

typedef list_iterator<T, T&, T*> iterator;
typedef list_iterator<T, const T&, const T*> const_iterator;

4.1 begin()函数

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

(1).begin()是一个迭代器，其作用是返回第一个有效数值的地址。

(2)._head是一个指向链表头节点的指针，这里的头节点并不存储有效数据，而是作为一个哨兵节点的存在。

(3)._head=_next是头节点的下一个节点，即链表中第一个存储有效数据的节点。

(4).iterator it(_head=_next) 创建了一个迭代器it，他初始化为指向链表的第一个有效元素。

4.2 end()函数

iterator end()
{
    iterator it(_head);
    return it;
}

(1).end()是一个迭代器，其作用是返回最后一个有效节点的下一个位置，也就是哨兵节点。

4.3 空初始化函数

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

void empty_init()函数在list类中有着重要作用，其作用为初始化链表为空状态的作用，这个函数的主要目的是创建一个哑节点(哨兵节点)，并设置链表的初始状态，使链表在逻辑上是空的。

4.4 深拷贝函数

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

list(const list<T>& lt)是一个拷贝构造函数，它用于创建一个新的list对象，该对象是另一个已存在list对象的深拷贝。这个拷贝构造函数通过遍历it并使用其元素来填充新创建的list，从而实现了深拷贝。

4.5 交换函数

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

实现了交换两个list的功能

4.6 赋值运算符operator=的实现

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

注意是传值传参，只是一个拷贝，在调用operator=时会创建一个list<T>的副本，这个副本是通过调用list的拷贝构造函数实现的。

在swap调用后，*this获得了it的原始资源，而it获得了*this的原始资源。

4.7 析构函数和clear()函数

void clear()
{
    auto it = begin();
    while (it != end())
    {
        it = erase(it); // 返回下一个的迭代器
    }
}

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

void clear()函数中,通过遍历整个list，再通过erase来销毁list。

析构函数中，直接调用了clear()函数。

4.8 push_back函数

void push_back(const T& x)
{
    Node* newnode = new Node(x);
    Node* tail = _head->_prev;//尾节点

    tail->_next = newnode;//更新尾节点的_next指针
    newnode->_prev = tail;//更新新节点的_prev指针
    newnode->_next = _head;//新节点的_next指向哨兵节点
    _head->_prev = newnode;//哨兵节点的_prev指向新节点
    _size++;//更新链表大小

    // insert(end(),x);
}

这个函数接受一个类型为constT&的参数x，即要插入的新元素的一个常量引用。使用常量引用是为了避免不必要的元素复制，同时保证传递给函数的对象不会被修改。

4.9 插入函数

void insert(iterator pos, const T& x)
{
    Node* cur = pos._node;//cur指向迭代器pos当前指向的节点
    Node* prev = cur->_prev;//prev指向cur的前一个节点

    Node* newnode = new Node(x);//创建一个新的节点newnode，并初始化为x

    newnode->_next = cur;//将新结点的_next指针指向cur。
    cur->_prev = newnode;//将当前位置的_prev指针更新为指向新节点，以保持双向链接
    newnode->_prev = prev;//将新节点_prev指针指向prev，即前一个节点
    prev->_next = newnode;//将前一个结点的_next指针更新为新结点，完成插入。

    _size++;//链表大小加一，因为插入了新数据
}

用于在链表的指定位置pos之前插入一个新的元素x。这个函数展示了如何在双向链表中高效的插入元素。

4.10 push_front函数

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

直接利用insert函数即可，将插入位置定为begin()。

4.11 erase函数

iterator erase(iterator pos)
{
    assert(pos != end());

    Node* prev = pos._node->_prev;//获得删除结点的前驱
    Node* next = pos._node->_next;//获得删除结点的后继

    prev->_next = next;//将前驱结点的_next指针指向后继结点
    next->_prev = prev;//将后继节点的_prev指针指向前驱结点

    delete pos._node;//删除pos位置的节点的内存

    _size--;//将链表大小减一
    return next;//返回被删除元素之后元素的迭代器
}

用于从双向链表中删除指定位置的元素，并返回指向被删除元素之后元素的迭代器。

4.12 头删和尾删

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

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

直接调用erase即可

4.13 size函数

size_t size() const
{
    return _size;
}

直接返回_size的大小即可

3.14 empty函数

 bool empty()
 {
     return _size == 0;
 }

直接返回_size是否等于0即可。

本篇完

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

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

相关文章

[译] How things get done on the Go Team

[译] How things get done on the Go Team

6天前&#xff0c;掌舵Go语言团队12年Rsc在golang-dev/群组发文宣布&#xff0c;将在9月1号后辞去当前职位&#xff0c;转去做 Gaby 和 Oscar. 这对于Go语言发展无疑是里程碑式的事件。 本篇内容是根据6月份他和另外两位同事参与Go Time音频录制内容的整理与翻译&#xff0c;英…
阅读更多...
代码随想录算法训练营Day22 | Leetcode 77 组合 Leetcode 216 组合总和Ⅲ Leetcode17 电话号码的字母组合

代码随想录算法训练营Day22 | Leetcode 77 组合 Leetcode 216 组合总和Ⅲ Leetcode17 电话号码的字母组合

前言 回溯算法中递归的逻辑不重要&#xff0c;只要掌握回溯的模板以及将问题转化为树形图&#xff0c;整个问题就很好解决了&#xff0c;比二叉树简单。 Leetcode 77 组合 题目链接&#xff1a;77. 组合 - 力扣&#xff08;LeetCode&#xff09; 代码随想录题解&#xff1a;…
阅读更多...
K-means聚类算法的应用以及实现

K-means聚类算法的应用以及实现

K-means 聚类算法属于无监督学习&#xff0c;它会将相似的对象归到同一个簇中&#xff0c;该算法原理简单&#xff0c;执行效率高&#xff0c;并且容易实现&#xff0c;是解决聚类问题的经典算法。 尽管如此&#xff0c;任何一款算法都不可能做到完美无瑕&#xff0c;K-measn 算…
阅读更多...
计算机毕业设计选题推荐-房屋租赁系统-Java/Python项目实战

计算机毕业设计选题推荐-房屋租赁系统-Java/Python项目实战

✨作者主页&#xff1a;IT研究室✨ 个人简介&#xff1a;曾从事计算机专业培训教学&#xff0c;擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Python…
阅读更多...
【python】python心理健康医学数据分析与逻辑回归预测（源码+数据集+论文）【独一无二】

【python】python心理健康医学数据分析与逻辑回归预测（源码+数据集+论文）【独一无二】

&#x1f449;博__主&#x1f448;&#xff1a;米码收割机 &#x1f449;技__能&#x1f448;&#xff1a;C/Python语言 &#x1f449;公众号&#x1f448;&#xff1a;测试开发自动化【获取源码商业合作】 &#x1f449;荣__誉&#x1f448;&#xff1a;阿里云博客专家博主、5…
阅读更多...
php 中 (0 == ‘abc‘) 为真

php 中 (0 == ‘abc‘) 为真

https://andi.cn/page/621653.html
阅读更多...
第129天：内网安全-横向移动WmiSmbCrackMapExecProxyChainsImpacket

第129天：内网安全-横向移动WmiSmbCrackMapExecProxyChainsImpacket

这里这个环境继续上一篇文章搭建的环境 案例一&#xff1a; 域横向移动-WMI-自带&命令&套件&插件 首先上线win2008 首先提权到system权限 wmic是windows自带的命令&#xff0c;可以通过135端口进行连接利用&#xff0c;只支持明文方式&#xff0c;优点是不用上传别…
阅读更多...
解决IDEA中Maven项目依赖已存在但仍报找不到的错误

解决IDEA中Maven项目依赖已存在但仍报找不到的错误

问题描述&#xff1a; 如图显示的是lombok存在 这里已经导入lombok依赖包 如图所示依赖包确实已经导入 解决方案&#xff1a; 点击后会重新启动项目&#xff0c;操作后我们重新配置一下maven 设置完后&#xff0c;点击重新引入就行
阅读更多...
JAVA实战项目笔记02

JAVA实战项目笔记02

一、新增员工 1.接口设计 2.设计数据库的employee表 3.设计DTO DTO&#xff1a;封装前端提交过来的数据 实体类如下&#xff1a;包含更多属性 public class Employee implements Serializable {private static final long serialVersionUID 1L;private Long id;private Str…
阅读更多...
vivado OPT_SKIPPED

vivado OPT_SKIPPED

当跳过候选基元单元的逻辑优化时&#xff0c;OPT_skipped属性 更新单元格以反映跳过的优化。当跳过多个优化时 在同一单元格上&#xff0c;OPT_SKIPPED值包含跳过的优化列表。 架构支持 所有架构。 适用对象 OPT_SKIPPED属性放置在单元格上。 价值观 下表列出了各种OPT_design选…
阅读更多...
使用ventoy制作U盘安装centos8

使用ventoy制作U盘安装centos8

使用ventoy制作U盘安装centos8 参考&#xff1a;https://blog.51cto.com/u_14120/11118656 推荐这个https://www.zhihu.com/question/290783457/answer/3103388484 1、ventoy官网 https://www.ventoy.net/en/download.html 2、下载完成直接制作u盘启动盘 4、将下载iso镜像…
阅读更多...
维特根斯坦：所谓天才，就是不放弃实践的勇气

维特根斯坦：所谓天才，就是不放弃实践的勇气

天才并不比任何一个诚实的人有更多的光&#xff0c;但他有一个特殊的透镜&#xff0c;可以将光线聚焦至燃点。 我象一个骑在马上的拙劣骑手一样&#xff0c;骑在生活上。我之所以现在还未被抛下&#xff0c;仅仅归功于马的良好本性。 一个人懂得太多就会发现&#xff0c;要不…
阅读更多...
大模型开源教程「动手学大模型应用开发」，从零基础到掌握大模型开发的关键技能！

大模型开源教程「动手学大模型应用开发」，从零基础到掌握大模型开发的关键技能！

LLM 正逐步成为信息世界的新革命力量&#xff0c;其通过强大的自然语言理解、自然语言生成能力&#xff0c;为开发者提供了新的、更强大的应用开发选择。随着国内外井喷式的 LLM API 服务开放&#xff0c;如何基于 LLM API 快速、便捷地开发具备更强能力、集成 LLM 的应用&…
阅读更多...
营销材料翻译质量对销售渠道的影响

营销材料翻译质量对销售渠道的影响

在当今的全球市场中&#xff0c;与不同受众进行有效沟通的能力对于企业的成功至关重要。营销材料的高质量翻译在通过销售渠道塑造客户旅程方面发挥着重要作用&#xff0c;影响着知名度、参与度、转化率和保留率。方法如下&#xff1a; 提高品牌知名度 在销售渠道的顶端&#x…
阅读更多...
Android 14 Power键亮灭屏流程

Android 14 Power键亮灭屏流程

Android14中Power键的事件分发和Android10的是不一样的&#xff0c;这里并没有经过interceptKeyBeforeDispatching方法&#xff0c;而是直接走到了interceptKeyBeforeQueueing方法 PhoneWindowManager中的堆栈如下 07-06 08:59:04.481 1844 1984 D WindowManager: intercep…
阅读更多...
鸿蒙（API 12 Beta2版）媒体开发【使用AudioCapturer开发音频录制功能】

鸿蒙（API 12 Beta2版）媒体开发【使用AudioCapturer开发音频录制功能】

如何选择音频录制开发方式 系统提供了多样化的API&#xff0c;来帮助开发者完成音频录制的开发&#xff0c;不同的API适用于不同录音输出格式、音频使用场景或不同开发语言。因此&#xff0c;选择合适的音频录制API&#xff0c;有助于降低开发工作量&#xff0c;实现更佳的音频…
阅读更多...
HDFS写入数据的流程图

HDFS写入数据的流程图

1.客户端向namenode发送请求&#xff0c;请示写入数据 2.namenode接受请求后&#xff0c;判断这个用户是否有写入权限&#xff0c;如果不具备直接报错&#xff1b;如果有写入权限&#xff0c;接着判断在要写入的目录下是否已经存在这个文件&#xff0c;如果存在&#xff0c;直…
阅读更多...
通过python搭建文件传输服务器；支持多台电脑之间互相传输文件（支持局域网或广域网）（应该也能用于虚拟机和宿主机之间）

通过python搭建文件传输服务器；支持多台电脑之间互相传输文件（支持局域网或广域网）（应该也能用于虚拟机和宿主机之间）

因为公司网络防火墙限制，所以在公司的电脑之间传输文件还是非常不方便的；所以自己搭建了一个文件传输服务器，用于多台电脑间的文件传输； 先放上最终效果： 文章目录 一、运行环境要求二、环境搭建2.1 安装python2.2 搭建虚拟环境方法1：创建Anaconda虚拟环境方法2：创建pyt…
阅读更多...
Java线程池的这几个大坑，你踩过几个？

Java线程池的这几个大坑，你踩过几个？

首先看一个简单的例子&#xff1a;代码可能会抛出空指针异常,但这个异常就会被吞掉。 要优雅解决问题&#xff0c;可以为线程池设置一个全局的异常处理器,使用自定义的线程工厂来设置! java public class CustomThreadFactory implements ThreadFactory { private final Threa…
阅读更多...
CTFHUB-web-RCE-综合过滤练习

CTFHUB-web-RCE-综合过滤练习

开启题目 查看网页源代码发现这次网页对 | 、 && 、 || 、 \ 、 / 、; &#xff0c;都进行了过滤处理 发现换行符 %0a 和回车符 %0d 可以进行测试&#xff0c;在 URL 后面拼接访问 127.0.0.1%0als 用 ls flag_is_here 查看 flag 文件中的内容&#xff0c;发现回显为空…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023