C++ list类成员函数介绍

news2024/11/20 14:24:28

目录

🤔list模板介绍：

🤔特点：

🤔list内存结构图解：

🤔 list的成员函数：

😊list构造函数：

🔍代码示例：

🔍运行结果：

😊list赋值函数：

🔍代码实例：

🔍运行结果：

😊list判断函数：

🔍代码实例：

运行结果：

😊 list的删除和插入

🔍代码实例：

运行结果：

😊list存取函数

🔍代码实例：

🔍运行结果：

😊 list反转和排序函数：

🔍代码实例：

🔍运行结果：

😊 list实用特殊函数：

🔍2.merge：

🔍3.cbegin，crbegin，cend，crend

结束！

🤔list模板介绍：

                        📖C++中的list是一个双向链表模板类，提供了一系列方便的链表操作方法，比如在列表前后插入/删除元素、访问节点和迭代器等。它的底层实现是双向链表、由节点构成的结构，节点包含指向前一个节点和后一个节点的指针，使得链表的查找、插入和删除操作都比较高效。与vector相比，list不支持随机访问，但提供了更快的在任意位置进行插入和删除操作能力，list一般用于动态添加或删除元素比较多的情况，例如LRU缓存中存储最近使用过的数据。

🤔特点：

📖1. 双向链表结构：list以双向链表的形式存储元素，每个节点包含一个元素值和指向前一个和后一个节点的指针。因此，在list中插入、删除元素可以较为高效地实现。

📖2. 不支持随机访问：list不支持随机访问，并不能像vector和array一样通过下标来访问节点，而需要通过迭代器或指针来操作。

📖3. 动态添加和删除元素：由于其底层为链表结构，list可以在任意位置高效地进行元素插入、删除操作，而不需要移动其他元素，通过这一点，list可以用于需要频繁添加和删除元素的场景。

4. 迭代器支持：list提供了迭代器的支持，可以通过迭代器遍历整个链表，或者实现反向遍历。

📖5. 内存空间管理：list为每个元素分配堆空间，因此不同于vector，list对元素的添加或删除操作能够避免因为内存重分配带来的性能损失。

📖6. 没有实现数据的置换：list中不包含像set和map这些关联式容器实现的数据置换机制。如果需要实现数据的置换，可以使用其他关联式容器，例如红黑树，AVL树等。

📖7. list迭代器不支持加减操作：由于链表的结构和迭代器的本质，list迭代器不支持加减操作，例如it = it + 1，但支持递增和递减，例如++it和--it。

总的来说，list能够高效实现插入或删除元素，并可以通过迭代器遍历整个链表。由于需要为每个元素分配堆空间，因此list也会占用比vector更多的内存空间。

🤔list内存结构图解：

🤔 list的成员函数：

😊list构造函数：

📖1.默认构造函数：list <T>   lst；

list<int>b;

📖2..将[beg,end)区间的元素拷贝给自身 ： list（beg,end）;

list<int>c(b.begin(),b.end());

📖3.将n个elem拷贝给本身： list(n,elem)；

list<int>d(8,10);

📖4.拷贝构造函数  list (const list &list)；

list<int>d(8,10);

🔍代码示例：

#include<iostream>
using namespace std;
#include<list>
void printa(const list<int>& d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << "  ";
	}
	cout << endl;
}
void test01()
{
	//默认构造为：
	list<int>b;
	for (int i = 0; i < 10; i++)
	{
		b.push_back(i);
	}
	cout << "默认构造结果为：";
	printa(b);

	//区间构造为：
	list<int>c(b.begin(),b.end());
	cout << "区间构造结果为：";
	printa(c);

	//n个elem构造：
	list<int>d(8,10);
	cout << "n个elem构造结果为：";
	printa(d);

	//拷贝构造：
	list<int>e(d);
	cout << "赋值构造结果为：";
	printa(e);

}
int main()
{
 test01();
}

🔍运行结果：

😊list赋值函数：

📖1.将[beg,end）区间中的数据拷贝赋值给本身:   assign(beg,end);

b1.assign(b.begin(), b.end());

📖2.将n个elem赋值给本身:     assign(n,elem) ;

b2.assign(10, 8);

📖3.重载等号运算符:     list & opertor =（const list &list ）;

list<int>b3;
b3 = b2;

📖4.将list与本身元素互换:    swap（）;

list<int>b4;b4.swap(b3);

🔍代码实例：

#include<iostream>
using namespace std;
#include<list>
void printa(const list<int>& d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << "  ";
	}
	cout << endl;
}
void test01()
{
	//默认构造为：
	list<int>b;
	for (int i = 0; i < 10; i++)
	{
		b.push_back(i);
	}
	cout << "默认构造结果为：";
	printa(b);

	list<int>b1;
	b1.assign(b.begin(), b.end());
	cout << "区间拷贝结果为：";
	printa(b1);

	list<int>b2;
	b2.assign(10, 8);
	cout << "区间拷贝结果为：";
	printa(b1);

	list<int>b3;
	b3 = b2;
	cout << "重载等号结果为：";
	printa(b3);

	list<int>b4;
	b4.swap(b3);
	cout << "交换后结果为：";
	printa(b4);
}
int main()
{
 test01();
}

🔍运行结果：

😊list判断函数：

📖1返回容器中的元素个数：    size()
📖2.返回容器是否为空：     empty()
📖3.重新指定容器的长度为num。若容器变长，就以默认值填充新位置，若容器变短，则超出的被删除：        resize(num);
📖4.重新指定容器的长度为num。若容器变长，就以ele值填充新位置，若容器变短，则超出的被删除：       resize(num,elem);

🔍代码实例：

 #include<iostream>
using namespace std;
#include<list>
void printa(const list<int>& d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << "  ";
	}
	cout << endl;
}
void test01()
{
	//默认构造为：
	list<int>b;
	for (int i = 0; i < 10; i++)
	{
		b.push_back(i);
	}
	cout << "默认构造结果为：";
	printa(b);

	cout << "b容器是否为空（1为空，0不为空）" << b.empty()<<endl;
	cout << "b容器的大小为：" << b.size()<<endl;
	b.resize(11);
	cout << "无ele的resize结果为：";
	printa(b);
	cout << endl;
	b.resize(12,9);
	cout << "有ele的resize结果为：";
	printa(b);
	
}
int main()
{
 test01();
}

运行结果：

😊 list的删除和插入

📖1.在容器尾部加入一个容器                               push_back(elem)；

📖2.删除容器中最后一个元素                               pop_back()；

📖3.在容器开头插入元素                                      push_front(ele)；

📖4.删除第一个元素                                              pop_front()；

📖5.在pos位置插入                                                eleminsert(pos, elem)；

📖6.在pos位置插入n个eleminsert                       （pos，n, elem）；

📖7.在pos位置插入区间beg，end的所有元素        insert（pos，beg，end）；

📖8.移除容器中的所有元素                                    clear();

📖9.删除beg到end的所有元素                                earse(beg, end)；

📖10.删除pos位置的数据                                         earse（pos）；

📖11.删除容器中所有与ele匹配的值                       remove（ele）；

🔍代码实例：

 #include<iostream>
using namespace std;
#include<list>
void printa(const list<int>& d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << "  ";
	}
	cout << endl;
}
void test01()
{
	//默认构造为：
	list<int>b;
	for (int i = 0; i < 10; i++)
	{
		b.push_back(i);
	}
	cout << "默认构造结果为：";
	printa(b);

	b.push_back(1);
	cout << "在尾部插入数字后：";
	printa(b);

	b.pop_back();
	cout << "在尾部删除数字后：";
	printa(b);

	b.push_front(1);
	cout << "在头部插入数字后：";
	printa(b);

	b.pop_front();
	cout << "在头部删除数字后：";
	printa(b);
	
	b.insert(b.begin(), 98);
	cout << "在头部插入数字98后：";
	printa(b);

	b.insert(b.begin(), 3,98);
	cout << "在头部插入3个数字98后：";
	printa(b);

	b.clear();
	cout << "在使用clear函数后：";
	printa(b);

	//重新赋值：
	for (int i = 0; i < 10; i++)
	{
		b.push_back(i);
	}
	b.remove(8);
	cout << "在使用参数为8的remove函数后";
	printa(b);

	b.erase(b.begin());
	cout << "使用erase函数对begin位置删除后";
	printa(b);

	b.erase(b.begin(),b.end());
	cout << "使用erase函数对begin到end区间删除后";
	printa(b);

	
}
int main()
{
 test01();
}

运行结果：

😊list存取函数

📖1.返回第一个元素：front（）
📖2.返回最后一个元素：back()

🔍代码实例：

 #include<iostream>
using namespace std;
#include<list>
void printa(const list<int>& d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << "  ";
	}
	cout << endl;
}
void test01()
{
	//默认构造为：
	list<int>b;
	for (int i = 0; i < 10; i++)
	{
		b.push_back(i);
	}
	cout << "默认构造结果为：";
	printa(b);

	cout << "打印front函数的返回值：";
	cout << b.front();
	cout << endl;
	cout << "打印back函数的返回值：";
	cout << b.back();
}
int main()
{
 test01();
}

🔍运行结果：

😊 list反转和排序函数：

📖1.反转链表 reverse();
📖2.排序  sort（）；

🔍代码实例：

 #include<iostream>
using namespace std;
#include<list>
void printa(const list<int>& d)
{
	for (list<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << "  ";
	}
	cout << endl;
}
void test01()
{
	//默认构造为：
	list<int>b;
	for (int i = 0; i < 10; i++)
	{
		b.push_back(i);
	}
	cout << "默认构造结果为：";
	printa(b);

	cout << "调用reverse函数之后";
	b.reverse();
	printa(b);
	cout << endl;
	cout << "调用sort函数之后：";
	b.sort();
	printa(b);
}
int main()
{
 test01();
}

🔍运行结果：


 

😊 list实用特殊函数：

🔍1.unique：

📖在C++ STL的list容器中，unique是一个函数，它用于去除list容器中邻近并且相等的元素，时间复杂度为O(N)，其中N为list容器大小。

template<class T> void list<T>::unique();

📖该函数检查容器中相邻的元素，并删除重复的元素。

📖举个例子，如果list容器中包含如下元素：{1, 2, 2, 3, 3, 3}，那么如果你调用unique函数，它将会把容器变为：{1, 2, 3}，即将每个相邻并且相等的元素删除并仅保留一个。

📖需要注意的是，在使用unique函数之前必须将list容器进行排序，因为该函数仅能识别相邻、相等的元素，如果元素未排序，它将无法正确地识别相邻的元素是否相等。

📖如果需要自定义去重的判定条件，可以将自定义的判断函数作为参数传递给unique函数，这样它可以根据自定义规则去重。例如：

bool compare(int a, int b) {
    return abs(a) < abs(b);
}

int main() {
    std::list<int> mylist { 1, 2, -2, 3, -3, -3 };
    mylist.sort();
    mylist.unique(compare);
    for (auto it=mylist.begin(); it!=mylist.end(); ++it)
        std::cout << ' ' << *it;
    return 0;
}

📖该代码使用自定义比较函数compare()，它将每个元素的绝对值作为比较条件，去除相邻的绝对值相等的元素，输出结果为1 2 3。

🔍2.merge：

📖在C++ STL的list容器中，merge()函数用于将两个已排序的list容器合并为单个list，并保持其排序顺序。该函数的用法如下：

template<class T> void list<T>::merge(list<T>& x);

📖该函数将x的元素合并到当前容器中，并确保保持排序顺序。

📖举个例子，如果有两个list容器，分别为：

std::list<int> list1 { 1, 3, 5 };
std::list<int> list2 { 0, 2, 4 };

📖如果你对它们进行merge()操作，那么list2中的元素将被移动到list1容器中，并保持排序顺序，最终list1容器变为：{0, 1, 2, 3, 4, 5}。

📖需要注意的是，在使用merge()函数之前必须将list容器进行排序，否则结果将是未定义的。

🔍3.cbegin，crbegin，cend，crend

📖cbegin() 和 cend() 返回指向容器中第一个元素和最后一个元素的常量迭代器。其中，最后一个元素指的是那个值与 list::end() 的返回值相等的元素的下一个位置。这些函数的返回类型是 const_iterator，这意味着它们返回的迭代器是指向常量值的。

📖而 crbegin() 和 crend() 则返回指向容器中最后一个元素和第一个元素的常量反向迭代器。这些函数的返回类型是 const_reverse_iterator。

结束！

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

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

相关文章

python图像处理实战（二）—二值化图像与线性变换

python图像处理实战（二）—二值化图像与线性变换

&#x1f680;写在前面&#x1f680; &#x1f58a;个人主页&#xff1a;https://blog.csdn.net/m0_52051577?typeblog &#x1f381;欢迎各位大佬支持点赞收藏&#xff0c;三连必回&#xff01;&#xff01; &#x1f508;本人新开系列专栏—python图像处理 ❀愿每一个骤雨初…
阅读更多...
什么是时间复杂度？

什么是时间复杂度？

时间复杂度定义&#xff1a;在计算机科学中&#xff0c;时间复杂性&#xff0c;又称时间复杂度&#xff0c;算法的时间复杂度是一个函数&#xff0c;它定性描述该算法的运行时间。这是一个代表算法输入值的的长度的函数。时间复杂度常用大O符号表述&#xff0c;不包括这个函数的…
阅读更多...
Python篇——数据结构与算法（第四部分：希尔排序及其讨论、计数排序、桶排序、基数排序）

Python篇——数据结构与算法（第四部分：希尔排序及其讨论、计数排序、桶排序、基数排序）

1、希尔排序 希尔排序&#xff08;shell sort&#xff09;是一种分组插入排序算法首先取一个整数d1n/2&#xff0c;将元素分为d1个组&#xff0c;每组相邻两元素之间距离为d1&#xff0c;在各组内进行直接插入排序取第二个整数d2d1/2&#xff0c;重复上述分组排序过程&#xf…
阅读更多...
SpringCloud Alibaba Seata 工作机制

SpringCloud Alibaba Seata 工作机制

SpringCloud Alibaba Seata Seata 工作机制 说明 之所以放在后面说工作机制是因为如果一开始就说的话理解困难 所以我们有了前面的列子和说明我们在结合本节内容会收获的多理解相对容易点 分布式事务过程分析 Seata 分布式事务处理过程-ID三组件模型 debug 梳理: 术语 先…
阅读更多...
C++ deque类成员函数介绍

C++ deque类成员函数介绍

目录 &#x1f914;deque模板介绍&#xff1a; &#x1f914;deque特点&#xff1a; &#x1f914;deque内存结构图解&#xff1a; &#x1f914;deque各操作地址指向&#xff1a; &#x1f914; deque的成员函数&#xff1a; deque构造函数&#xff1a; &#x1f50d;代…
阅读更多...
C++ 常见集合算法

C++ 常见集合算法

目录 &#x1f914;常见集合算法&#xff1a; &#x1f642;1.set_intersection 容器交集 代码示例&#xff1a; 运行结果&#xff1a; &#x1f642;2.set_union 容器并集 图解&#xff1a; 代码示例&#xff1a; 运行结果&#xff1a; &#x1f642; 3.set_differe…
阅读更多...
高速缓存(cache)的原理: 了解计算机架构与性能优化

高速缓存(cache)的原理: 了解计算机架构与性能优化

计基之存储器层次结构 Author&#xff1a; Once Day Date&#xff1a; 2023年5月9日 长路漫漫&#xff0c;而今才刚刚启程&#xff01; 本内容收集整理于《深入理解计算机系统》一书。 参看文档: 捋一捋Cache - 知乎 (zhihu.com)iCache和dCache一致性 - 知乎 (zhihu.com)C…
阅读更多...
【SpringCloud——Elasticsearch（上）】

【SpringCloud——Elasticsearch（上）】

一、什么是Elasticsearch elasticsearch是一款非常强大的开源搜索引擎&#xff0c;可以帮助我们从海量数据中快速找到需要的内容。 二、倒排索引 1、正向索引 2、倒排索引 3、总结 三、ES和MySQL的区别 四、操作索引库 1、基于Kibana&#xff08;WEB界面&#xff09; 以下操作…
阅读更多...
jvisualvm ssl远程连接JVM

jvisualvm ssl远程连接JVM

jvisualvm 远程ssl连接 一、没认证的 JMX连接 (不安全) 这种方式&#xff0c;仅限于测试环境&#xff0c;可以这样操作。生产环境为了安全起见&#xff0c;还是要使用带认证的方式连接。 远程jar包服务 启动时 java -jar [jvm参数] xx.jar添加JVM参数 java -jar -Xmx512M -Xms2…
阅读更多...
基于深度学习的高精度汽车自行车检测识别系统（PyTorch+Pyside6+模型）

基于深度学习的高精度汽车自行车检测识别系统（PyTorch+Pyside6+模型）

摘要&#xff1a;基于深度学习的高精度汽车自行车检测识别系统可用于日常生活中检测与定位汽车自行车目标&#xff0c;利用深度学习算法可实现图片、视频、摄像头等方式的汽车自行车目标检测识别&#xff0c;另外支持结果可视化与图片或视频检测结果的导出。本系统采用YOLOv5目…
阅读更多...
基于深度学习的高精度野生动物检测识别系统（PyTorch+Pyside6+YOLOv5模型）

基于深度学习的高精度野生动物检测识别系统（PyTorch+Pyside6+YOLOv5模型）

摘要&#xff1a;基于深度学习的高精度野生动物检测&#xff08;水牛、犀牛、斑马和大象&#xff09;识别系统可用于日常生活中或野外来检测与定位野生动物目标&#xff0c;利用深度学习算法可实现图片、视频、摄像头等方式的野生动物目标检测识别&#xff0c;另外支持结果可视…
阅读更多...
Flutter问题记录 - TextField组件多行提示文本显示不全

Flutter问题记录 - TextField组件多行提示文本显示不全

文章目录 前言开发环境问题描述问题分析解决方案最后 前言 梳理Flutter项目的过程中发现还有一些遗留的TODO没处理&#xff0c;其中有一个和TextField组件相关。 开发环境 Flutter: 3.10.1Dart: 3.0.1 问题描述 TextField组件设置maxLines: null不限制行数&#xff0c;同时…
阅读更多...
【文章学习系列之模型】SCALEFORMER

【文章学习系列之模型】SCALEFORMER

本章内容 文章概况模型结构主要方法多尺度框架跨尺度标准化模型输入编码损失函数 实验结果消融实验跨尺度标准化自适应损失函数 总结 文章概况 《SCALEFORMER: ITERATIVE MULTI-SCALE REFINING TRANSFORMERS FOR TIME SERIES FORECASTING》是2023年发表于ICLR上的一篇论文。作…
阅读更多...
硬件工程师-BUCK开关电源设计

硬件工程师-BUCK开关电源设计

一、电感的伏安特性 电感线圈通电之后&#xff0c;会产生磁场&#xff0c;磁场是有一定极性的&#xff0c;而且磁场分布&#xff0c;是一个封闭的回路。在线圈的内部磁力线是比较密集的&#xff0c;磁场的强度是比较强的&#xff0c;外面空气中的的这个磁力线是比较稀疏的&…
阅读更多...
【Unity3D】调整屏幕亮度、饱和度、对比度

【Unity3D】调整屏幕亮度、饱和度、对比度

1 屏幕后处理流程 调整屏幕亮度、饱和度、对比度&#xff0c;需要使用到屏幕后处理技术。因此&#xff0c;本文将先介绍屏幕后处理流程&#xff0c;再介绍调整屏幕亮度、饱和度、对比度的实现。 屏幕后处理即&#xff1a;渲染完所有对象后&#xff0c;得到一张屏幕图像&#xf…
阅读更多...
Centos6.5环境Nginx 1.16.1升级到1.24.0版本

Centos6.5环境Nginx 1.16.1升级到1.24.0版本

一、背景 2023年4月11日&#xff0c;官方发布了Nginx最新稳定版&#xff0c;版本号为 1.24.0。该版本是基于1.23.x&#xff08;1.23.0 - 1.23.4&#xff09;开发版的Bug修复&#xff0c;以及一些新特性的加入&#xff0c;而形成的稳定版。安全部门扫描后&#xff0c;发现现场不…
阅读更多...
车载ECU休眠唤醒-TJA1145

车载ECU休眠唤醒-TJA1145

前言 首先&#xff0c;请教大家几个小小问题&#xff0c;你清楚&#xff1a; 什么是TJA1145吗&#xff1f;你知道休眠唤醒控制基本逻辑是怎么样的吗&#xff1f;TJA1145又是如何控制ECU进行休眠唤醒的呢&#xff1f;使用TJA1145时有哪些注意事项呢&#xff1f; 今天&#xff…
阅读更多...
chatgpt赋能python：Python中如何输入中文——从安装到常见问题解决

chatgpt赋能python：Python中如何输入中文——从安装到常见问题解决

Python中如何输入中文——从安装到常见问题解决 Python是一门广泛使用的编程语言&#xff0c;其优秀的开源性、易用性、灵活性以及庞大的生态圈也令越来越多的人选择Python。但是对于初学者来说&#xff0c;如何正确输入中文常常成为一个问题。本篇文章从安装、常见问题解决、…
阅读更多...
LeetCode 560 和为 K 的子数组

LeetCode 560 和为 K 的子数组

LeetCode 560 和为 K 的子数组 来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode.cn/problems/subarray-sum-equals-k/description 博主Github&#xff1a;https://github.com/GDUT-Rp/LeetCode 题目&#xff1a; 给你一个整数数组 …
阅读更多...
ChatGPT的4个不为人知却非常实用的小功能

ChatGPT的4个不为人知却非常实用的小功能

今天重点介绍四个ChatGPT很实用的小功能。 一、停止生成 如果在ChatGPT输出内容的过程中&#xff0c;我们发现结果不是自己想要的&#xff0c;可以直接点击“Stop generating”按钮&#xff0c;这样它就会立即停止输出。 二、复制功能 在ChatGPT返回对话的右侧&#xff0c;有三…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023