模板类模拟实现List

最新推荐文章于 2021-05-12 23:22:53 发布
最新推荐文章于 2021-05-12 23:22:53 发布
阅读量1.2k 收藏 2
点赞数 1
分类专栏： C++ 文章标签： class list 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_36118270/article/details/62417319
版权

　　上一篇中我模拟实现了vector，接着这个当然就是list了，首先对于list，在库函数里面，list是一个双向的，即既含有next域，也含有prev域，每个节点都含有这样的结构，我们在写的时候要把一个一个链接上，而且要保证逻辑正确，作者本人就在拷贝构造函数的时候懵逼了半天。所以一个表示节点的结构体必须有，这个当然也可以用类，但是你会感觉本质上你还是用类中结构体的性质，所以还是结构体方便一点。
　　

template<class T>
struct ListNode
{
    ListNode(const T& x = T())      //构造函数，给_prev,_next,_value初始化
    : _prev(0)
    , _next(0)
    , _value(x)
    { }

    ListNode<T>* _prev;
    ListNode<T>* _next;
    T _value;
};

　　这个想必大家都很熟悉，所以我就不多说了，然后为了更好、更快捷、明了的表示一个节点，或者是对这个节点做一些操作，我们最好在封装一个类，确实，我是按库里面写的，库里也包含了这个类，采用了迭代器的用法，目前，我们只当迭代器是一个指针，这样才能更直观的理解我们现在的用法。

　　和库里面一样，我也把很多类型名定义成自己顺手的自定义类型。

template<class T, class Ref, class Ptr>
struct __ListIterator__
{
    typedef __ListIterator__<T, T&, T*> Iterator;
    typedef __ListIterator__<const T, const T&, const T*> ConstItrator;
    typedef __ListIterator__<T, Ref, Ptr> Self;
    typedef T ValueType;
    typedef Ref Reference;
    typedef Ptr Pointer;
    typedef ListNode<T>*  LinkType;
    typedef size_t SizeType;

    LinkType _node;
public:
    __ListIterator__(LinkType x)
        :_node(x)
    { }

    __ListIterator__()
        :_node(0)
    { }

    __ListIterator__(const Iterator& x)
        :_node(x._node)
    { }

    bool operator==(const Iterator& x)
    {
        return x._node == _node;
    }

    bool operator!=(const Iterator& x)
    {
        return x._node != _node;
    }

    Reference operator*()
    {
        return _node->_value;
    }

    Pointer operator->()
    {
        return &(*(_node->_value));
    }

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

    Self operator++(int)
    {
        Self temp(*this);
        _node = _node->_next;
        return temp;
    }

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

    Self operator--(int)
    {
        Self temp(*this);
        _node = _node->_prev;
        return temp;
    }
};

　　最后就该到list的模板类了，这才是重中之重，我也是到这里迷失了一段时间，一个函数改了好久，几近崩溃（小白吐槽而已）。不说了，对这代码再给你说说我的逻辑。


template<class T>
class List
{
public:
    typedef ListNode<T> Node;
    typedef T ValueType;
    typedef ValueType* Pointer;
    typedef const ValueType* ConstPointer;
    typedef ValueType& Reference;
    typedef const ValueType& ConstReference;
    typedef Node* LinkType;
    typedef size_t SizeType;
    typedef __ListIterator__<T, T&, T*> Iterator;
    typedef __ListIterator__<const T, const T&, const T*> ConstIterator;

　　 //无参的构造函数，当然一进去就要先开辟好空间
　　 //等着其他的函数什么调用的时候有插入、删除的空间
　　 //并且要构成一个环，

　　 这里写图片描述
　　

    List<T>()
    {
    　　 _node = new Node;
    　　  _node->_next = _node;
    　　  _node->_prev = _node;
    　　  _node->_value = 0;
    }

　　这个函数让我很是尴尬，我的思维逻辑很清晰，在这个函数出错的时候，我还专门找人讨论我的逻辑，绝对没毛病，但是就是有问题，索性放着美观，过了一天，早上打开又理了一次，一次就出来了。所以我get到了一个技能，有时候，歇一歇，放松一下对自己也有帮助。

    List<T>(const List<T>& l)
    {
        _node = new Node;//给this的_node先开辟好空间
        LinkType MoveNode = _node;//然后新定义一个节点，表示尾节点
        LinkType srcNode = new Node;
        srcNode = l._node;//创建一个节点，表示被拷贝对象的头结点
        LinkType destNode = new Node;//创建新节点，用来储存拷贝节点的数据，再链接到尾节点上
        while (srcNode->_next != l._node)//当l的最后一个节点被拷贝完后，停止拷贝
        {
            destNode = new Node;//每次进去：开辟空间->储存数具->链接上尾节点

            MoveNode->_next = destNode;
            destNode->_prev = MoveNode;
            destNode->_next = _node;
            _node->_prev = destNode;

            srcNode = srcNode->_next;
            MoveNode = MoveNode->_next;
        }
    }

示意图：
插入一个节点
这里写图片描述
插入两个节点
这里写图片描述
以此类推，每次进来先和尾节点的next域相连，然后把新节点的prev域指向尾节点，还要记得的是，一定要和头结点相连，即上述操作完成之后，将新节点的next域指向头结点，将头结点的prev域指向尾节点，这样才是一个循环的双向链表，假如你本意不循环的话，让我没说，但是记得你的节点的netx域要指空。

赋值运算符的操作没啥说的，和拷贝构造的一样，多加个返回值而已，最起码这个函数是这样。逻辑都是一样的。


    List<T>& operator=(const List& l)
    {
        _node = new Node;
        LinkType MoveNode = _node;
        LinkType srcNode = new Node;
        srcNode = l._node;
        LinkType destNode = new Node;
        while (srcNode->_next != l._node)
        {
            destNode = new Node;
            destNode->_value = srcNode->_next->_value;
            MoveNode->_next = destNode;
            destNode->_prev = MoveNode;
            destNode->_next = _node;
            _node->_prev = destNode;
            srcNode = srcNode->_next;
            MoveNode = MoveNode->_next;
        }
        return *this;
    }

这里写代码片

    Iterator Insert(Iterator pos, const T& x)
    //插入函数，在pos位置的前面插入
    {
        LinkType temp = new Node(x);
        pos._node->_prev->_next = temp;
        temp->_prev = pos._node->_prev;
        temp->_next = pos._node;
        pos._node->_prev = temp;
        return temp;
    }

删除节点的图解：
这里写代码片

    Iterator Erase(const T& value)
    {
        Iterator pos = Find(value);
        Iterator temp = pos;
        temp++;
        pos._node->_prev->_next = pos._node->_next;
        pos._node->_next->_prev = pos._node->_prev;
        delete pos._node;
        return temp;
    }


    Iterator Begin()
    {
        return _node->_next;
    }

    ConstIterator Begin()const
    {
        return _node->_next;
    }

    Iterator End()
    {
        return _node;
    }

    ConstIterator End()const
    {
        return _node;
    }

    bool Empty()const
    {
        return Begin() == End();
    }

    SizeType Size()
    {
        SizeType size = 0;
        Iterator temp = Begin();
        while (temp._node != _node)
        {
            temp._node = temp._node->_next;
            size++;
        }
        return size;
    }

    Reference Front()
    {
        return _node->_next->_value;
    }

    ConstReference Front()const
    {
        return _node->_next->_value;
    }

    Reference Back()
    {
        return _node->_prev->_value;
    }

    ConstReference Back()const
    {
        return _node->_prev->_value;
    }

    void PushFront(const T& x)
    {
        Insert(Begin(), x);
    }

    void PushBack(const T& x)
    {
        Insert(End(), x);
    }


    void PopFront()
    {
        Delete(_node->_next);
    }

    void PopBack()
    {
        Delete(_node->_prev);
    }

    void Delete(Iterator pos)
    {
        Iterator temp = pos;
        temp._node->_prev->_next = temp._node->_next;
        temp._node->_next->_prev = temp._node->_prev;
        delete temp._node;

    }
    void Clear()
    {
        while (Begin() != End())
        {
            Delete(Begin());
        }
        _node->_next = _node;
        _node->_prev = _node;
        _node->_value = 0;
    }

    ~List()
    {
        Iterator temp;
        Clear();
    }

    friend ostream& operator<<(ostream& os, List<T>& L)
    {
        Iterator temp = L.Begin();
        Iterator END = L.End();
        while (temp._node != END._node)
        {
            cout << temp._node->_value << " ";
            temp._node = temp._node->_next;
        }
        return os;
    }

protected:
    Iterator Find(const T& value)
    {
        Iterator temp = _node;
        while (temp._node->_value != value)
        {
            temp._node = temp._node->_next;
        }
        return temp;
    }

private:
    LinkType _node;
};
DZ小明
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
不是吧，到现在还不知道FreeMarker是什么？
dirft_din的博客
07-02 798
FreeMarker 概述 FreeMarker概念 ​ FreeMarker 是一款 模板引擎： 即一种基于模板和要改变的数据， 并用来生成输出文本(HTML网页，电子邮件，配置文件，源代码等)的通用工具。 是一个Java类库。 ​ FreeMarker 被设计用来生成 HTML Web 页面，特别是基于 MVC 模式的应用程序，将视图从业务逻辑中抽离处理，业务中不再包括视图的展示，而是将视图交给 FreeMarker 来输出。虽然 FreeMarker 具有一些编程的能力，但通常由 Java 程序准备要
list类的C++模板实现
执念如此Arcon的博客
07-26 2085
/* 2017/07/20 Liu YK */#pragma once #include <iostream> #include <ctime> #include <cassert> #include <cstdlib>namespace MYSTL {#define ListNodePosi(T) ListNode<T>* typedef int Rank; template<typ
list 模板类的简单实现
zhangziyangup
12-11 494
最近学数据结构，于是尝试着去实现了一个 list 类，发现确实有很多问题，特别是类的继承这一块，有些问题搞不懂…… 这个 list 类只是一个简单的实现，只提供了基本的功能，也没有边界检测什么的，越界访问的问题由使用者自己把握…… 很多功能都是没有实现的，总得来说这是一个比较裸的 list 模板类，没有什么实用价值…… /* THE PROGRAM IS MADE BY PYY */ ...
C++模板类实现std::list
junior19的博客
05-16 979
list是以链表为底层的STL容器，下面用模板类实现它的基本功能，部分思路参考C++泛型STL原理和应用。 list实现的函数： push_front() push_back() pop_front() pop_back() begin() end() size() 迭代器重载了： = == != ++ -- * # include <iostrea...
创建一个数据类型为T的链表类模板List，实现以下成员函数的模拟测试.cpp
06-04
3) 用List模板定义一个List类型的模板类对象int_listA，调用List的成员函数实现A = B + C；（4分） 4) 用cout直接输出int_listA的所有元素（3分） 5) 用List模板定义List类型的模板类对象double_listA, double_...
C++ 模拟实现list(迭代器)实现代码
08-30
C++ 模拟实现 List（迭代器）实现代码 C++ 模拟实现 List（迭代器）是指使用 C++ 语言来模拟实现 List 数据结构，并提供迭代器来遍历 List 中的元素。在本文中，我们将介绍如何使用 C++ 语言来模拟实现 List（迭代...
双向链表List模板类（模拟STL容器中的list）
02-07
双向链表List模板类（模拟STL容器中的list），提供插入删除，清空，获取链表长度，判断链表是否为空等操作，内置了迭代器类型
C++程序(类模板)
09-29
`Vector`是一个模板类，它提供了类似于STL`vector`的功能，如`push_back()`、`resize()`等。`Vector`类有三个私有成员变量：`alist`存储元素的动态数组，`size`表示当前元素数量，`capacity`表示数组的容量。构造...
stack类模板源代码
04-26
下面，我们来分析`stack`类模板的关键实现细节。在`<stack>`头文件中，`stack`类模板定义如下： ```cpp template , class Container = deque<T> > class stack { private: Container c; // 使用的容器 public: /...
C++模板的实现（模板函数和模板类，附带模板实现顺序表和链表代码）
龙跃十二
05-05 3128
模板 一、模板函数 模板函数的格式： 模板参数隐式实例化 模板参数显示实例化 二、模板类 模板类的格式 模板类示例 模板  当我们实现一个交换函数时，我们可以写成如下。 void Swap(int&amp; x, int&amp; y) { int tmp = x; x = y; y = tmp; }  这里只能交换两个整数...
STL：模拟实现List(迭代器版本的List）
dangzhangjing97的博客
08-11 1060
一、什么是List？ List是STL标准库中的一个容器，相当于链表 二、List的优点？ 1.通用性（因为List的实现使用了模板）
链表模板类的定义
Reyes Yang's Utopia
10-23 1360
//------------------------------------------ClassLinkList.h------------------------------------------template class linkList;template class Link{friend class linkList;private:        T data;     
C++---list(列表)模板
qq_42708024的博客
11-10 1325
list介绍 list模板类也是一个容器。list是由双向链表实现，每个节点存储一个元素。list支持前后两种移动方向。 list优势在于可以在任何位置上进行插入、删除，同时也可以双向迭代。 list与vector的区别 list不支持随机访问 list没有下标访问符[]和at()函数 list没有提供容量，空间操作的函数，每个元素都有自己的内存。list的底层是双向链表结构，双向链表中每个元素...
实现list-- 模板
weixin_40417029的博客
05-17 692
实现一个带头结点的双向带环链表：观察这样一个链表（写出代码如下）：//List.h #pragma once #include &lt;assert.h&gt...
数据结构（C语言版） 19页List类模板实现
qq_40772639的博客
09-25 261
/* * 课本第19页，类模板实现 */ #include <iostream> using namespace std; template <typename T> class List { private: const int LIST_INIT_SIZE = 100; T *_elem; int _length = 0; int _capacity = LIST_INIT_SIZE; public: List(); //InitLi
线性表容器list类模板-C++实现
m0_55464171的博客
05-12 332
线性表是一种常用的数据类型，本文将用双链表实现一个线性表结构的类模板 1）线性表容器声明 //declear class list template<typename ElementType> class list { private: struct DataNode; //储存数据的结构体类型 typedef DataNode*NodePtr; //指向储存数据的指针类型 NodePtr head, tail; //数据的头结点，尾结点 int _size; //当前线性表的数据量
Java的List模板类型与C++的list模板类型的比较
chy19911123的专栏
10-09 1080
http://blog.csdn.net/leopardaa521/article/details/5736825 Java的List只是一个容器接口，定义List必须用一些实现类如ArrayList来实现。 对List使用需要理解几个关键点：     ①List的add()方法只能添加对象，无法添加基本数据类型！     ②List不会自己去开辟空间来复制add()添
list的底层实现
baiwenbo1997的博客
04-03 5312
list的介绍 list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。 list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高 效。 比特科技 构造函数 接口说明 l...
设计一个底层容器为链表类模板Listr<T>的适配器，要求实现年龄大于80岁的人优先拍队首的队列，测试main函数中依次在队列中插入18,22,88三个数来模拟不同年龄的三个人，然后进行核酸检测出队并显示。
最新发布
06-12
为了实现这个类，我们用 `Listr` 作为底层容器，并定义了一个 `Person` 结构体表示每个人的年龄和核酸检测结果。在 `main` 函数中，我们随机生成 3 个人的年龄和检测结果，并插入到队列中。然后依次弹出队首元素，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值