C++STL【list链表】

news2025/1/21 10:22:41

list

1. list介绍

  • list文档（非官方）
    官方文档
  • list是双向带头循环链表，它可以在常数范围内的任意位置进行插入和删除操作。
  • list的迭代器是双向迭代器(bidirectional iterator)，它可以前后双向迭代。
    由容器的底层结构决定，STL迭代器有不同的种类：
    在这里插入图片描述
  • list的底层空间如下图所示：
    在这里插入图片描述
  • 正因list的底层空间如此，它相比其他容器：
    优点：在任意位置插入、删除元素的执行效率更高（相比vector、deque等）；
    缺点：不支持位置的随机访问，要访问某个节点，需要迭代器迭代；需要开辟额外的空间来储存下一个节点、上一个节点的地址；缓存命中率低。

2. list的常用接口

  • 与vector一样，list的许多接口中有很多别名：
    在这里插入图片描述

  1. 构造函数(constructor)

    (constructor)功能
    explicit list (const allocator_type& alloc = allocator_type());默认构造函数
    explicit list (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type());用n个val值初始化
    template <class InputIterator>
    list (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());    		用迭代器初始化（可以允许其他类型作为参数初始化）
    list (const list& x);拷贝构造函数
    list<int> lt1;
list<int> lt2(3, 2);
int nums[] = { 1,2,3 };
list<int> lt3(arr, arr + 3);
list<int> lt4(v3);

  2. 容量操作

    函数功能
    size_type size(); const返回有效元素个数
    bool empty(); const判断是否为空
    void resize (size_type n, value_type val = value_type());改变有效元素个数

  3. 迭代器

    函数功能
    iterator begin();
    const_iterator begin() const;    		返回容器开头的位置的迭代器
    iterator end();
    const_iterator end() const;    		返回容器最后一个有效元素的下一个位置的迭代器
    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;    		返回容器最后一个有效元素的位置的迭代器
    reverse_iterator rend();
    const_reverse_iterator rend() const;    		返回容器开头的前一个位置的迭代器

    关于list的迭代器：

    1. 迭代器一般是指针，在string和vector中，因为底层空间是连续的，所以它们的迭代器可以直接使用指针；但是list不行，因为它的空间不是连续的，是多块由指针连接的小空间。因此list的迭代器必须做出改变，即重新封装。

    2. list的迭代器如下：
      在这里插入图片描述
      list迭代器被重新封装成为一个类，它的成员变量是一个节点的类型的指针，指向节点；另外在迭代器类中，还实现了一系列运算符重载，如*/->/!=/==/++/--，使得其与别的容器的迭代器功能一致。

    3. 关于迭代器内运算符->的重载：

    重载operator->，编译器进行了特殊处理。

    struct A
{
	A(int a1 = 0, int a2 = 0)
		: _a1(a1)
		, _a2(a2)
	{ }

	int _a1;
	int _a2;
};
void Test()
{
	list<A> la;
	A aa(1, 2);
	la.push_back(aa);
	list<A>::iterator it = la.begin();
	cout << it->_a1 << endl;
}

    operator->返回的是A*，it->_a1就等价于 A * _ a1，这不合语法，正确写法应该是it->->_a1，但是这么写很难看，于是编译器做了优化，自动替我们加上了一个->，于是我们只需写成这样即可：it->_ val

    1. 迭代器提供了一种不暴露容器底层设计的方法来访问容器内容。

  4. 访问元素

    函数功能
    reference front();
    const_reference front() const;    		访问链表开头一个元素
    reference back();
    const_reference back() const;    		访问链表最后一个元素
    int nums[] = { 1,2,3 };
list<int> lt(arr, arr + 3);
cout << lt.front() << endl;
cout << lt.back() << endl;

  5. 修改操作

    函数功能
    void push_back (const value_type& val);尾插一个值
    void pop_back();尾删一个值
    void push_front (const value_type& val);头插一个值
    void pop_front();头删一个值
    insert在某个位置插入元素
    erase删除某个位置的元素
    void swap (list& x);交换两个list对象
    void clear();清空有效元素

  6. 链表操作
    STL还提供了一些链表操作，如sort、reverse等，但是不常使用，这里就不多介绍了，若要查看，请移步官方文档。

3. 模拟实现list（部分接口）

#pragma once
#include<iostream>
#include<assert.h>

using namespace std;

namespace Myspace
{
	template <class T>
	struct list_node
	{
		list_node(const T& value = T())
			: _next(nullptr)
			, _pre(nullptr)
			, _val(value)
		{ }

		list_node<T>* _next;
		list_node<T>* _pre;
		T _val;
	};

	// 正向迭代器
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef __list_iterator<T, Ref, Ptr> Self; // Self表示自己
		typedef list_node<T> Node;

		__list_iterator(Node* node = nullptr)
			: _node(node)
			{ }

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

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

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

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

		Ref operator*()
		{
			return _node->_val;
		}

		Ptr operator->()
		{
			return &(_node->_val);
		}

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

		Node* _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;


		///
		// <构造>
		void CreatHead()
		{
			_head = new Node;
			_head->_next = _head->_pre = _head;
		}

		list()
		{
			CreatHead();
		}

		list(int n, const T& _value = T())
		{
			CreatHead();
			while (n--)
			{
				push_back(_value);
			}
		}

		template<class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			CreatHead();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		list(const list<T>& lt)
		{
			CreatHead();
			//for (auto e : lt)
			//{
			//	push_back(e);
			//}
			list<T> temp(lt.begin(), lt.end());
			this->swap(temp);
		}

		list<T> operator=(list<T> lt)
		{
			if (lt._head != _head)
			{
				swap(lt);
			}
			return *this;
		}


		///
		// <迭代器>
		iterator begin()
		{
			return _head->_next; // 单参数的构造函数，可以进行整型提升，Node* 提升为iterator
		}

		iterator end()
		{
			return _head;
		}

		const_iterator begin() const
		{
			return _head->_next; // 单参数的构造函数，可以进行整型提升，Node* 提升为iterator
		}

		const_iterator end() const
		{
			return _head;
		}

		///
		// <容量>
		size_t size()
		{
			size_t sz = 0;
			Node* cur = _head->_next;
			while (cur != _head)
			{
				sz++;
				++cur;
			}
			return sz;
		}

		bool empty()
		{
			return _head == _head->_pre;
		}

		void resize(size_t n, const T& value = T())
		{
			size_t sz = size();
			if (n < sz)
			{
				while (n < sz)
				{
					pop_back();
					sz--;
				}
			}
			else
			{
				while (sz < n)
				{
					push_back(value);
					sz++;
				}
			}
		}

		///
		// <访问>
		T& front()
		{
			return _head->_next->_val;
		}

		const T& front() const
		{
			return _head->_next->_val;
		}

		T& back()
		{
			return _head->_pre->_val;
		}

		const T& back() const
		{
			return _head->_pre->_val;
		}

		///
		// <删除、插入>
		void push_back(const T& value)
		{
			insert(end(), value);
		}

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

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

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

		iterator insert(iterator pos, const T& value = T())
		{
			Node* newnode = new Node(value); // 待插入的新节点
			Node* cur = pos._node; // 取出pos迭代器的节点
			newnode->_pre = cur->_pre;
			newnode->_next = cur;
			cur->_pre->_next = newnode;
			cur->_pre = newnode;

			return newnode;
		}

		iterator erase(iterator pos)
		{
			assert(pos._node != _head);
			Node* cur = pos._node;
			Node* ret = cur->_next; // 保留一下返回值
			cur->_pre->_next = cur->_next;
			cur->_next->_pre = cur->_pre;
			delete cur;
			return ret;
		}

		void clear()
		{
			Node* cur = _head->_next;
			while (cur != _head)
			{
				_head->_next = cur->_next;
				delete cur;
				cur = _head->_next;
			}
			_head->_next = _head->_pre = _head;
		}

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

	private:
		Node* _head;
	};
}

注意：

  1. 构造函数vector(int n, const T& value = T())接口需要重载多个（int/size_t/long），以防止创建对象时（vector<int> v(2,3);）编译器自动匹配到vector(InputIterator first, InputIterator last)这个接口。
    原因：编译器总会选择最匹配的接口。
  2. 在扩容时拷贝数据的时候，不要使用memcpy（上述代码的第151行），原因如下：
    如果模板实例化为string，那么此时就相当于memcpy(string1, string2, size)，将两个string类memcpy，一定是浅拷贝，因为string类本身有个char*的指针，需要动态开辟空间，memcpy仅仅是将两个指针指向了同一块空间，并没有开辟新的空间。
    直接赋值即可，赋值会调用string自己的赋值运算符重载，它自己会实现深拷贝。
    不止是string，其他任何动态管理空间的类都是如此。

4. 迭代器失效

list的结构是链状表，正因为它不是一块连续的空间，它的迭代器失效问题没有string和vector多。

只有在删除数据的时候，才可能引起迭代器失效。

  • 链表的insert没有迭代器失效的问题！
    因为没有扩容，不需要挪动数据，位置没有改变，迭代器还是指向那个节点。

  • 但是earse有迭代器失效的问题！
    因为节点释放了，迭代器却依旧指向那个位置。
    STL为erase增添了返回值，我们用完erase后要接收它的返回值，它返回的是删除的节点的下一个节点。

`，将两个string类memcpy，一定是浅拷贝，因为string类本身有个char*的指针，需要动态开辟空间，memcpy仅仅是将两个指针指向了同一块空间，并没有开辟新的空间。
直接赋值即可，赋值会调用string自己的赋值运算符重载，它自己会实现深拷贝。
不止是string，其他任何动态管理空间的类都是如此。

4. 迭代器失效

list的结构是链状表，正因为它不是一块连续的空间，它的迭代器失效问题没有string和vector多。

只有在删除数据的时候，才可能引起迭代器失效。

  • 链表的insert没有迭代器失效的问题！
    因为没有扩容，不需要挪动数据，位置没有改变，迭代器还是指向那个节点。

  • 但是earse有迭代器失效的问题！
    因为节点释放了，迭代器却依旧指向那个位置。
    STL为erase增添了返回值，我们用完erase后要接收它的返回值，它返回的是删除的节点的下一个节点。

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

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

相关文章

redis 性能优化一

redis 性能优化一

目录 前言 尾延迟 前言 说到redis 性能优化&#xff0c;优化的目的是什么&#xff1f;提高响应&#xff0c;减少延迟。就要关注两点&#xff0c;一是尾延迟&#xff0c;二是Redis 的基线性能。只有指标&#xff0c;我们的优化&#xff0c;才有意义&#xff0c;才能做监控以及…
阅读更多...
数智驱动“坐商”变“行商”，安通控股迈向综合物流服务新高度

数智驱动“坐商”变“行商”，安通控股迈向综合物流服务新高度

在全球经济增长放缓的大环境下&#xff0c;集装箱运输市场也面临供需双弱的新挑战。 国内内贸集装箱物流企业TOP3——安通控股股份有限公司&#xff08;以下简称“安通控股”&#xff09;激流勇进&#xff0c;积极推进营销理念从“业务操作型”向“客户营销型”转变、从传统的…
阅读更多...
英福康INFICON软件真空Tware32中文操作手册

英福康INFICON软件真空Tware32中文操作手册

英福康INFICON软件真空Tware32中文操作手册
阅读更多...
列表吸顶分组之按首字母分组国家选区号

列表吸顶分组之按首字母分组国家选区号

列表粘性分组之按首字母分组国家选区号 Android原生版本 直接先看UI图，效果如下 本来看起来也不难，我就想着上面常用区号那块不动，下面的列表滑动就行，但IOS说他滑动的时候上面也滑上去了，好吧，这也行；但最终效果做出来后，IOS滑动后会有按照国家名称首字母进行粘性分…
阅读更多...
[CSAWQual 2019]Web_Unagi ---不会编程的崽

[CSAWQual 2019]Web_Unagi ---不会编程的崽

不知道刷了多少天了&#xff0c;又是一题关于xxe漏洞的。 web的习惯性操作。 1.功能点&cms 2.源代码 3.敏感文件泄露 当然这是我个人的习惯。这里进入界面后又upload功能&#xff0c;不会是传马吧。但是旁边给了上传文件格式。仅仅只看界面似乎没什么区别&#xff0c;源…
阅读更多...
RabbitMQ 基本介绍

RabbitMQ 基本介绍

RabbitMQ 基本介绍 消息模型 所有 MQ 产品从模型抽象上来说都是一样的过程&#xff1a; 消费者&#xff08;consumer&#xff09;订阅某个队列。生产者&#xff08;producer&#xff09;创建消息&#xff0c;然后发布到队列&#xff08;queue&#xff09;中&#xff0c;最后…
阅读更多...
软考66-上午题-【面向对象技术】-小结+杂题

软考66-上午题-【面向对象技术】-小结+杂题

一、杂题 真题1&#xff1a; 真题2&#xff1a; 真题4&#xff1a; 真题5&#xff1a; 真题6&#xff1a; 二、面向对象设计-总结 2-1、考题分析 选择题&#xff1a;11道&#xff08;11分&#xff09; 综合分析题&#xff1a;2道&#xff08;30分&#xff09; java程序设计…
阅读更多...
react native中使用Animated实现三张图片动态旋转效果

react native中使用Animated实现三张图片动态旋转效果

react native中使用Animated实现三张图片动态旋转效果 效果示例图示例代码 效果示例图 示例代码 import React, {useEffect, useRef} from react; import {Animated, StyleSheet, View} from react-native; import {pxToPd} from ../../common/js/device;const TestShowCard …
阅读更多...
etcd入门指南

etcd入门指南

目录 一.etcd的介绍和发展 1.什么是etcd 2.ecsd的发展历史 3.etcd特点 4.使用场景 5.关键字 6.工作原理 7.下载地址 二.将etcd部署到linux 1.etcd安装前介绍 2.安装etcd 1. 创建并切换到下载目录 ​编辑 2.下载或者解压 3切换至etcd根目录&#xff0c;运行查看命令l…
阅读更多...
【Docker】转存Docker容器镜像

【Docker】转存Docker容器镜像

目录 导出 拷贝到其他服务器 导入 启动被导入镜像镜像保存 加载镜像 运行测试 导出 把正在运行中的容器导出到一个文件压缩包&#xff0c;然后可以传输到其他服务器进行运行 #导出容器文件系统成为一个tar文件 docker export #导入tar文件&#xff0c;成为一个镜像 dock…
阅读更多...
探索c++——了解c++的魅力

探索c++——了解c++的魅力

前言&#xff1a;c是一门既面向对象又面向过程的语言。 不同于java纯粹的面向对象和c纯粹的面向过程。 造成c该特性的原因是c是由本贾尼大佬在c的基础上增添语法创建出来的一门新的语言。 它既兼容了c&#xff0c; 身具面向过程的特性。 又有本身的面向对象的特性。 面向对象和…
阅读更多...
golang中go build 后读取配置文件

golang中go build 后读取配置文件

golang打包后读取配置文件 在用go写代码的时候&#xff0c;为了好用经常使用go build 打包&#xff0c;如果我们用到了配置文件&#xff0c;就总是导致不能找到文件所在位置了出现bug&#xff0c;所以以下代码就解决了这个问题。 核心代码&#xff1a; file, err : exec.Look…
阅读更多...
【打工日常】Linux实现可回滚的回收站功能

【打工日常】Linux实现可回滚的回收站功能

1.为什么创建可回滚的回收站功能&#xff1f; 为了让运维人员可以有回旋的余地&#xff0c;但是也要保证可以清理不需要的文件。 2.涉及到的文件安全概念&#xff1f; Linux的文件安全概念主要涉及到文件权限和文件系统安全两个方面。 那什么是文件权限&#xff1f; 在Linux系统…
阅读更多...
第三百八十六回

第三百八十六回

文章目录 概念介绍使用方法示例代码 我们在上一章回中介绍了Snackbar Widget相关的内容,本章回中将介绍TimePickerDialog Widget.闲话休提&#xff0c;让我们一起Talk Flutter吧。 概念介绍 我们在这里说的TimePickerDialog是一种弹出窗口&#xff0c;只不过窗口的内容固定显示…
阅读更多...
LeetCode142题：环形链表II（python3）

LeetCode142题：环形链表II（python3）

代码思路&#xff1a; 双指针的第一次相遇&#xff1a; 设两指针 fast&#xff0c;slow 指向链表头部 head 。 令 fast 每轮走 2 步&#xff0c;slow 每轮走 1 步。 fast 指针走过链表末端&#xff0c;说明链表无环&#xff0c;此时直接返回 null。 如果链表存在环&#xff0c;…
阅读更多...
点胶缺陷视觉检测都是怎么检测的？

点胶缺陷视觉检测都是怎么检测的？

点胶工艺是许多工业生产中不可或缺的一环&#xff0c;而点胶缺陷的存在往往直接影响到产品质量。为了提升点胶工艺的品质控制&#xff0c;点胶缺陷的视觉检测成为了一个重要的技术手段。 一、点胶缺陷的类型 点胶缺陷主要包括胶点大小不均、位置偏移、漏点、多点等。这些缺陷如…
阅读更多...
【Python爬虫实战】抓取省市级城市常务会议内容

【Python爬虫实战】抓取省市级城市常务会议内容

&#x1f349;CSDN小墨&晓末:https://blog.csdn.net/jd1813346972 个人介绍: 研一&#xff5c;统计学&#xff5c;干货分享          擅长Python、Matlab、R等主流编程软件          累计十余项国家级比赛奖项&#xff0c;参与研究经费10w、40w级横向 文…
阅读更多...
引入AndroidUSBCamera-master USB摄像头问题

引入AndroidUSBCamera-master USB摄像头问题

1&#xff0c;USB摄像头地址 GitHub - jiangdongguo/AndroidUSBCamera: &#x1f525;&#x1f525;&#x1f525;Flexible and useful UVC camera engine on Android platform, supporting multi-road cameras! 2&#xff0c;下载zip包 引入操作&#xff1a; 1&#xff0c;…
阅读更多...
Cloud-Sleuth分布式链路追踪(服务跟踪)

Cloud-Sleuth分布式链路追踪(服务跟踪)

简介 在微服务框架中,一个由客户端发起的请求在后端系统中会经过多个不同的服务节点调用来协同产生最后的请求结果,每一个前端请求都会形成一条复杂的分布式服务调用链路,链路中的任何一环出现高延时或错误都会引起整个请求最后的失败 GitHub - spring-cloud/spring-cloud-sl…
阅读更多...
第41期 | GPTSecurity周报

第41期 | GPTSecurity周报

GPTSecurity是一个涵盖了前沿学术研究和实践经验分享的社区&#xff0c;集成了生成预训练Transformer&#xff08;GPT&#xff09;、人工智能生成内容&#xff08;AIGC&#xff09;以及大语言模型&#xff08;LLM&#xff09;等安全领域应用的知识。在这里&#xff0c;您可以找…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023