STL之list模拟实现(反向迭代器讲解以及迭代器失效)

这次是关于list的模拟实现的代码,先看看下面的代码:

cpp 复制代码
#pragma once
#include <iostream>
#include "reve_iterator.hpp"
using namespace std;
namespace cc
{
 //链表节点
 template<class T>
 struct ListNode
 {
    T _val;
    ListNode *_next;
    ListNode *_prev;
    ListNode(const T& x=T())
        : _val(x)
        , _next(nullptr)
        , _prev(nullptr)
    {}
 }; 
 //迭代器
 template<class T,class ref,class ptr>
 struct list_iterator
 {
    typedef ListNode<T> Node;
    typedef list_iterator<T,ref,ptr> iterator;
    list_iterator(Node *node)
        : _node(node)
    {}
    iterator& operator++()
    {
        _node=_node->_next;
        return *this;
    }
    iterator operator++(int)
    {
        iterator tem(_node);
        _node=_node->_next;
        return tem;
    }
    iterator& operator++()const
    {
        _node=_node->_next;
        return *this;
    }
    iterator operator++(int)const
    {
        iterator tem(_node);
        _node=_node->_next;
        return tem;
    }
    iterator& operator--()
    {
        _node=_node->_prev;
        return *this;
    }
    iterator operator--(int)
    {
        iterator tem(_node);
        _node=_node->_prev;
        return tem;
    }
    bool operator!=(const iterator& d)const
    {
        return _node!=d._node;
    }
    ref operator*()const
    {
        return _node->_val;
    }
    ptr operator->()const
    {
        return &(_node->_val);
    }
    Node *_node;
 };
 //链表
 template<class T>
 class List
 {
public:
    typedef ListNode<T> Node;
    typedef list_iterator<T,T&,T*> iterator;
    typedef list_iterator<T,const T&,const T*> const_iterator;
    typedef reve_iterator<iterator,T&,T*> riterator;
    typedef reve_iterator<iterator,const T&,const T*> const_riterator;
    void init()
    {
        _head->_next=_head;
        _head->_prev=_head;
    }
    List()
        : _head(new Node)
    {
        _head->_next=_head;
        _head->_prev=_head;
    }
    template<typename Iterator>
    List(Iterator begin,Iterator end)
        : _head(new Node)
    {
        init();
        while(begin!=end)
        {
            push_back(*begin);
            begin++;
        }
    }
    List(const List<T>& d)
        : _head(nullptr)
    {
        List<T> tem(d.begin(),d.end());
        swap(tem);
    }
    List<T>& operator=(List<T> d)
    {
        swap(d);
        return *this;
    }
    iterator begin()
    {
        return iterator(_head->_next);
    }
    iterator end()
    {
        return iterator(_head);
    }
    riterator rbegin()
    {
        return riterator(_head);
    }
    riterator rend()
    {
        return riterator(_head->_next);
    }
    const_iterator begin()const
    {
        return const_iterator(_head->_next);
    }
    const_iterator end()const
    {
        return const_iterator(_head);
    }
    void swap(List<T>& d)
    {
        std::swap(_head,d._head);
    }
    void push_back(const T& x=T())
    {
        Node *cur=new Node(x);
        Node *tail=_head->_prev;
        tail->_next=cur;
        cur->_prev=tail;
        cur->_next=_head;
        _head->_prev=cur;
    }
private:
    Node *_head;
 };
}

上面是list的代码,其底层是一个带头双向循环的链表,实现的方法就不说了,相信大家已经都会了,然后自己实心的list我没有写析构函数等,这个也很简单,循环利用成员函数中的删除函数就可以。

先来说说个人认为比较重要的东西:

首先是迭代器失效:list迭代器的失效与vector不同,list的迭代器在插入时不会有迭代器失效的现象,只有在删除的时候才有迭代器失效的现象,插入没有失效现象的原因,很简单,就不多说,而删除导致迭代器失效的原因是,在删除一个节点的时候,我们把这个节点所占的空间已经给释放了,所以此时指向这个节点的指针已经是野指针了,所以导致迭代器失效。

其次就是反向迭代器的实现了,我们先看看下面的反向迭代器的代码:

cpp 复制代码
#pragma once
#include "list.hpp"
namespace cc
{
    template<class Iterator,class ref,class ptr>
    struct reve_iterator
    {
    public:
        typedef reve_iterator<Iterator,ref,ptr> riterator;
        reve_iterator(Iterator it)
            : It(it)
        {}
        bool operator!=(const riterator& d)const
        {
            return It!=d.It;
        }
        riterator& operator++()
        {
            It--;
            return *this; 
        }
        riterator operator++(int)
        {
            Iterator tem(It);
            It--;
            return riterator(tem);
        }
        riterator& operator++()const
        {
            It--;
            return *this; 
        }
        riterator operator++(int)const
        {
            Iterator tem(It);
            It--;
            return riterator(tem);
        }
        ref operator*()const
        {
            Iterator tem(It);
            return *(--tem);
        }
        ptr operator->()const
        {
            return &(*It);
        }
    private:
        Iterator It;
    };
}

以上就是反向迭代器实现的代码,在list中的迭代器,不像我们之前的迭代器是原生指针,list的迭代是我们的自己定义的类似于一个指针的类,个人理解其实就是指针,只不过这个指针被包装了,我们以前用的指针没有被包装而已。那就来说说实现方法吧。首先就是这个指针类的成员函数了,运算符的重载一定要有,具体的看上面代码。主要讲解的是,因为反向迭代器的实现底层是在正向迭代器的基础上实现的,所以反向迭代中的++对于正向迭代器来说,就是--,一定要区分开这个。再就是"->"的重载其实是为了以防万一,防止val的值是一种类,这样的话就可以访问这个类的值了。

以上就是本篇的内容,如果对你们有帮助的话,希望点一下赞!谢谢支持!

相关推荐
孞㐑¥2 小时前
Linux之Socket 编程 UDP
linux·服务器·c++·经验分享·笔记·网络协议·udp
柳鲲鹏3 小时前
WINDOWS最快布署WEB服务器:apache2
服务器·前端·windows
水木兰亭5 小时前
数据结构之——树及树的存储
数据结构·c++·学习·算法
专注VB编程开发20年6 小时前
开机自动后台运行,在Windows服务中托管ASP.NET Core
windows·后端·asp.net
CoderCodingNo6 小时前
【GESP】C++四级考试大纲知识点梳理, (7) 排序算法基本概念
开发语言·c++·排序算法
秋风&萧瑟8 小时前
【C++】C++中的友元函数和友元类
c++
梁诚斌8 小时前
使用OpenSSL接口读取pem编码格式文件中的证书
开发语言·c++
李洋-蛟龙腾飞公司8 小时前
HarmonyOS NEXT应用元服务常见列表操作分组吸顶场景
linux·运维·windows
码农垦荒笔记9 小时前
Git 安装闭坑指南(仅 Windows 环境)
windows·git
阿幸软件杂货间10 小时前
Windows 10 2016 长期服务版
windows·系统·win10