初识《list》及手搓模拟《list》

无双@2024-04-26 11:44

目录

前言：

[1. list的介绍及使用](#1. list的介绍及使用)

list的介绍：

list的使用：

1、list的构造​编辑

[2、list iterator的使用](#2、list iterator的使用)

[3、list capacity](#3、list capacity)

[4、list element access](#4、list element access)

[5、list modifiers](#5、list modifiers)

2.list的模拟实现

1、关于迭代器：

2、迭代器类的封装：

3、模板为类的时候：

4、关于const迭代器：

一：而额外封装一个const迭代器。const_iterator

二：利用模板

3.vector与list的区别：

总结：

前言：

现阶段我们已经逐渐熟悉了各个STL库中的容器，对于他们的各个接口都大差不差，在我们学习完vector之后我们就可以陆陆续续接触一些算法题。我们的《好题分析》这一专栏也会不断的进行更新！下面我们先来熟悉以下list这个容器。

1. list的介绍及使用

list的介绍：

  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
  2. list的底层是双向带头链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
  3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
  4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
  5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)

list的使用：

1、list的构造

2、list iterator的使用

此处，大家可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。

注意！！

  1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动

  2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

3、list capacity

4、list element access

5、list modifiers

6、list的迭代器失效

前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了 。因为list的底层结构为带头结点的双向循环链表 ，因此在list中进行插入时是不会导致list的迭代器失效的 ，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

cpp 复制代码 
void TestListIterator1()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, array + sizeof(array) / sizeof(array[0]));
	auto it = l.begin();
	while (it != l.end())
	{
		// erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，
        // 必须先给其赋值
		l.erase(it);
		++it;
	}
}

// 改正
void TestListIterator()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, array + sizeof(array) / sizeof(array[0]));
	auto it = l.begin();
	while (it != l.end())
	{
		l.erase(it++); // it = l.erase(it);
	}
}

2.list的模拟实现

1、关于迭代器：

我们对list的迭代器的理解与我们之前对于string 和 vector中的iterator的理解有十分大的区别。string和vector的迭代器我们可以替换理解为指针，在我们遍历vector或者string时，仅需要对++运算符进行重载，我们就可以拿到下一个位置的值，而operator++()也很好理解，就是指针+1指向下一个下标的位置。

但是这次我们的list就大有不同，我们都知道list是一个带头的双向链表，而想要获得下一个结点的数据，应当是node = node -> next; 如果我们将运算符++重载为这个代码，那对于其它的代码想要运用++操作符，就纯粹扯淡。

这个时候的唯一解决方法就是------------------------++封装一个类！！！++

2、迭代器类的封装：

cpp 复制代码 
// 一个结点的结构！！！
template<class T>
struct ListNode
{
	T _data;
	ListNode<T>* _next;
	ListNode<T>* _prev;

	ListNode(const T& x = T())
		:_next(nullptr)
		, _prev(nullptr)
		, _data(x)
	{}
};

// 将迭代器封装成一个类
template<class T>
struct ListIterator
{
	typedef ListIterator<T> Self;
	typedef ListNode<T> Node;

	Node* _node;// iterator

	ListConstIterator(Node* node)
		:_node(node)
	{}

	bool operator != (const Self& it)
	{
		return _node != it._node;
	}

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

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

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

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

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

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

我们在之后的项目中，如果发现我们目前处理的数据中的内置类型不满足我们的需求，不妨我们可以将其封装成一个类！！！

首先我们先通过画图得方式来理解代码：

因为这个iterator类我们并不会定义私有成员，所以我们这里用的struct来定义。

而我们在整个链表的总体类中，我们需要先找到两个 头 和 尾 结点的位置，即begin 和 end.

cpp 复制代码 
	iterator begin()
	{
		return iterator(_head->_next); // 匿名对象
        // iterator it(_head->_next); // 调用 iterator类 里面的 构造函数
        // return it;
	}


	iterator end()
	{
    	return iterator(_head); // 匿名对象
        // iterator it(_head); // 调用 iterator类 里面的 构造函数
        // return it;
	}

3、模板为类的时候：

想要去到_a1, 若是不进行函数重载, 则代码为:

cpp 复制代码 
list<A>::iterator it = ls.begin();
std::cout << it._node->_data._a1 << " " << it._node->_data._a2 << std::endl;
it++;
std::cout << it._node->_data._a1 << " " << it._node->_data._a2 << std::endl;

很明显代码非常的冗长和麻烦, 因此我们可以利用函数重载:

cpp 复制代码 
T* operator->()
{
    return &_node->_data;
}
cpp 复制代码 
list<A>::iterator it = ls.begin();
std::cout << it->_a1 << " " << it->_a2 << std::endl;
it++;
std::cout << it->_a1 << " " << it->_a2 << std::endl;

it.operator->()->_a1
在这里编译器会自动优化代码，将代码的可读性提高。

it->_a1 <==> it.operator->()->_a1 <==> it->->_a1

通过公式推导，我们不难发现 it->_a1 <==> it->->_a1 这两个式子是等价的

4、关于const迭代器：

const迭代器，需要的是迭代器指向的内容不能被修改而const iteratror 作返回值时，代表了迭代器的指向不可被修改。

一：而额外封装一个const迭代器。const_iterator

在我们实施这个方法后，我们会发现仅仅只有Self& operator*() 和 Self* operator->()的返回值是需要加const，其它的都不变

cpp 复制代码 
 //对于每一个容器来说，都有存在const的类型接口，因此我们也需要创建一个const迭代器。
 //（运用const主要还是 防止 在进行 拷贝构造 或者 ++ -- 等出现 修改一个 const链表的情况。）
template<class T>
struct List_const_iterator
{
    typedef ListNode<T> Node;
    typedef List_const_iterator<T> Self;

    Node* _node;// 最重要的一行代码，代表在 List_iterator 类中 封装一个 _node 用来指向结点，通过在类里面
    // 控制运算符重载来操纵迭代器

    List_const_iterator(Node* node) // 传值构造
        :_node(node)
    {}

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

    // it++
    Self operator++(int)
    {
        Self tmp(*this); // 无需写拷贝构造函数， 默认的 浅拷贝 即可完成操作
        _node = _node->_next;
        return *this;
    }

    // *it
    const T& operator*()
    {
        return _node->_data;
    }

    // it->_data，此时的 _data 是结构体时才调用
    const T* operator->()
    {
        return &_node->_data;
    }

    bool operator!=(const Self& it)
    {
        return _node != it._node;
    }

};

因此我们没必要多此一举。

二：利用模板

cpp 复制代码 
// 我们在创建 const_iterator 迭代器时发现在整个类中，仅仅只是对 operator*() 与 operator->() 的返回值进行了修改
// 为了尽可能的减少代码量，利用模板是一个不错的选择。
// Ref == reference    ,    Prt == pointer
//                      T&         T* 
template<class T, class Ref, class Ptr> 
//template<class T>
struct List_iterator
{
    typedef ListNode<T> Node;
    typedef List_iterator<T, Ref, Ptr> Self;

    Node* _node;// 最重要的一行代码，代表在 List_iterator 类中 封装一个 _node 用来指向结点，通过在类里面
                // 控制运算符重载来操纵迭代器
    
    List_iterator(Node* node) // 传值构造
        :_node(node)
    {}

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

    // it++
    Self operator++(int)
    {
        Self tmp(*this); // 无需写拷贝构造函数， 默认的 浅拷贝 即可完成操作
        _node = _node->_next;
        return *this;
    }
    
    // *it 返回类型为T&
    Ref operator*()
    {
        return _node->_data;
    }


    // it->_data，此时的 _data 是结构体时才调用, 返回类型为T*
    Ptr operator->()
    {
        return &_node->_data;
    }

    bool operator!=(const Self& it)
    {
        return _node != it._node;
    }

};

在list类中：

cpp 复制代码 
 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 List_const_iterator<T> const_iterator;
     // 构造函数创建 哨兵位 的头结点

利用模板是最高效的方法！！！

3.vector与list的区别：

vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

总结：

本文的代码思路与之前大为不同，本次首先接触到了利用类封装一个迭代器，其次是对结点里的类进行分类讨论，从而引出对->运算符的重载，再然后又对const的迭代器进行了扩展，发现利用模板可以有效的解决出现的一系列问题。

代码在我的Gitee：

​​​​​​​my_list_practices_2/my_list_practices_2/list.h · 无双/C_Plus_Plus_Acer - Gitee.com

相关推荐
雨中rain5 分钟前
Linux -- 从抢票逻辑理解线程互斥
linux·运维·c++
就爱学编程7 分钟前
重生之我在异世界学编程之C语言小项目：通讯录
c语言·开发语言·数据结构·算法
ALISHENGYA1 小时前
全国青少年信息学奥林匹克竞赛（信奥赛）备考实战之分支结构（实战项目二）
数据结构·c++·算法
arong_xu1 小时前
现代C++锁介绍
c++·多线程·mutex
汤姆和杰瑞在瑞士吃糯米粑粑1 小时前
【C++学习篇】AVL树
开发语言·c++·学习
DARLING Zero two♡2 小时前
【优选算法】Pointer-Slice：双指针的算法切片（下）
java·数据结构·c++·算法·leetcode
CodeClimb2 小时前
【华为OD-E卷-木板 100分（python、java、c++、js、c）】
java·javascript·c++·python·华为od
奶香臭豆腐2 小时前
C++ —— 模板类具体化
开发语言·c++·学习
不想当程序猿_2 小时前
【蓝桥杯每日一题】分糖果——DFS
c++·算法·蓝桥杯·深度优先
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10RAG 实践- Ollama+RagFlow 部署本地知识库