C++ list类成员函数介绍

目录

🤔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。

结束！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

RobotFramework接口测试方案

RobotFramework接口测试方案

1. Robot FrameWork介绍 1.1 介绍 Robot Framework是用于验收测试和回归测试的通用测试自动化框架。它使用易于理解的表格数据语法&#xff0c;非常友好的实现了关键字驱动和数据驱动模式。它的测试功能可以通过使用Python或Java实现的测试库进行扩展&#xff0c;用户可以使用…
阅读更多...
【JavaSE】Java基础语法(十七)

【JavaSE】Java基础语法(十七)

文章目录 1. final2. 代码块2.1 代码块概述2.2 代码块分类 1. final fianl关键字的作用 final代表最终的意思&#xff0c;可以修饰成员方法&#xff0c;成员变量&#xff0c;类 final修饰类、方法、变量的效果 fianl修饰类&#xff1a;该类不能被继承&#xff08;不能有子类&a…
阅读更多...
软件测试基础概念

软件测试基础概念

目录 软件测试的生命周期如何描述一个bug如何定义bug的级别bug的生命周期产生争执怎么办&#xff08;处理人际关系&#xff09;如何开始第一次测试测试的执行和bug管理如何发现更多的bug 软件测试的生命周期 需求分析 – 测试计划 – 测试设计、测试开发 – 测试执行 – 测试评…
阅读更多...
界面控件DevExpress WinForms全新的UI模板，解决各种业务线需求！

界面控件DevExpress WinForms全新的UI模板，解决各种业务线需求！

去年秋天DevExpress官方发布了一个新的 WinForms UI模板预览版&#xff08;第一个EAP只提供给DevExpress宇宙版激活的用户&#xff09; &#xff0c;这些精炼的、随时可用的“模板”旨在启动表单设计/开发过程。有了这个模板&#xff0c;用户可以创建/交付现成的UI解决方案&…
阅读更多...
Jenkins——maven 插件配置

Jenkins——maven 插件配置

文章目录 一、Maven 的集成二、在执行job的机器上安装好maven三、下载 maven 插件四、配置全局工具五、Maven 相关使用1、新建 job2、自由风格 job 中命令行使用 mvn 命令3、构建操作 一、Maven 的集成 在 Jenkins 上构建 Java 项目时需要使用 Maven 来进行构建打包 二、在执…
阅读更多...
cisp pte模拟题

cisp pte模拟题

1.信息搜集 本题共三个key 端口 1433 27689 存活ip 192.168.85.137 2.访问网站27689进行信息搜集 一个登录框&#xff0c;sql注入失败&#xff0c;暴力破解失败 扫描目录 发现三个文件robots.txt ,web.config 除了robots.txt,其他都访问不了 访问robots.txt,发现一个file参数…
阅读更多...
在职阿里8年，一个31岁女软件测试工程师的心声

在职阿里8年，一个31岁女软件测试工程师的心声

简单的先说一下&#xff0c;坐标杭州&#xff0c;13届本科毕业&#xff0c;算上年前在阿里巴巴的面试&#xff0c;一共有面试了有6家公司&#xff08;因为不想请假&#xff0c;因此只是每个晚上去其他公司面试&#xff0c;所以面试的公司比较少&#xff09; 其中成功的有4家&am…
阅读更多...
chatgpt赋能python：使用Python创建结构体：完全指南

chatgpt赋能python：使用Python创建结构体：完全指南

使用Python创建结构体&#xff1a;完全指南 在Python编程领域&#xff0c;结构体是一种非常方便和有用的数据类型&#xff0c;用于存储和组织相关变量。在本篇文章中&#xff0c;我们将讨论如何使用Python创建结构体。让我们开始吧&#xff01; 什么是结构体&#xff1f; 结…
阅读更多...
CodeForces..构建美丽数组.[简单].[情况判断].[特殊条件下的最小值奇偶问题]

CodeForces..构建美丽数组.[简单].[情况判断].[特殊条件下的最小值奇偶问题]

题目描述&#xff1a; 题目解读&#xff1a; 给定数组a[n]&#xff0c;ai>0&#xff0c;问能否得到一个数组b[n]&#xff0c;数组b中的元素都大于0且全奇or全偶。 数组b中的元素biai or ai-aj&#xff08;1<j<n&#xff09;。 解题思路&#xff1a; 数组b中的元素都…
阅读更多...
Zotero之多篇文献引用

Zotero之多篇文献引用

前提 需看下我的这篇&#xff1a;Zotero文献在word中的引用 具体操作 Step01 在Word中引用多篇文献 点击“Add/Edit Citation”在跳出的Zotero搜索框中&#xff0c;选择“经典视图”在跳出的“添加/编辑引注”界面中&#xff0c;点击“多重来源”&#xff08;单一来源&…
阅读更多...
[图表]pyecharts模块-反转柱状图

[图表]pyecharts模块-反转柱状图

[图表]pyecharts模块-反转柱状图 先来看代码&#xff1a; from pyecharts import options as opts from pyecharts.charts import Bar from pyecharts.faker import Fakerc (Bar().add_xaxis(Faker.choose()).add_yaxis("商家A", Faker.values()).add_yaxis("…
阅读更多...
Spring 事件相关知识ApplicationEvent

Spring 事件相关知识ApplicationEvent

Spring 事件相关知识ApplicationEvent 事件工作流程相关类ApplicationListenerApplicationEvent 我们可以发布自己的事件ApplicationEventPublisher Spring框架中提供了多种事件类型&#xff0c;常用的几个事件类型如下&#xff1a; Spring 事件驱动模型是 Spring 框架中的一个…
阅读更多...
oracle安装

oracle安装

服务端安装&#xff08;公司中不需要&#xff0c;只安装客户端就行&#xff09; 1、挂载一个Windows系统 双击vmx文件 启动 2、网络配置 添加一个网络 自己电脑看控制面板是否添加虚拟网卡 查看连接的网络&#xff0c;ip地址不能为1&#xff0c;为1就自己修改&#xff0c;…
阅读更多...
【剑指offer】数据结构——数

【剑指offer】数据结构——数

目录 数据结构——数直接解【剑指offer】43. 1&#xff5e;n 整数中 1 出现的次数【剑指offer】44. 数字序列中某一位的数字【剑指offer】49. 丑数【剑指offer】60. n个骰子的点数【剑指offer】62. 圆圈中最后剩下的数字【剑指offer】64. 求12…n 特殊解——分治法 &#xff1a…
阅读更多...
用反射设计通用的实例化对象方案

用反射设计通用的实例化对象方案

需求 对象的相关信息存储在javabean.properties文件中&#xff0c;通过读取properties文件中的信息&#xff0c;实例化对象&#xff0c;要求程序不能硬编码&#xff0c;即程序可以通用&#xff0c;针对不同的对象&#xff0c;都可以实例化。仅需修改配置文件&#xff0c;不需要…
阅读更多...
【课代表笔记】直播回顾：Top药企的数字化实践集锦

【课代表笔记】直播回顾：Top药企的数字化实践集锦

【K讲了】系列直播之医药行业第一期&#xff1a;Top药企的数字化实践集锦前不久已在视频号和大家如期见面&#xff0c;以下是课代表为大家抄好的笔记~~ 斯歌K2的医药行业经验 K2在医药领域拥有丰富的客户积累及实施经验&#xff0c;全球TOP 10药企中有7家选择K2。斯歌K2已在医药…
阅读更多...
数据链路层：封装成帧

数据链路层：封装成帧

1.数据链路层&#xff1a;封装成帧 笔记来源&#xff1a; 湖科大教书匠&#xff1a;封装成帧 声明&#xff1a;该学习笔记来自湖科大教书匠&#xff0c;笔记仅做学习参考 封装成帧是指数据链路层给上层交付的协议数据单元添加帧头和帧尾使之成为帧 帧头和帧尾中包含重要的控制…
阅读更多...
java的UDP（一）

java的UDP（一）

文章目录 1. 简介2. UDP客户端3. UDP服务器4. DatagramPacket类 1. 简介 Java中的UDP实现分为两个类&#xff1a;DatagramPacket和DatagramSocket。DatagramPacket类将数据字节填充到UDP包汇总&#xff0c;这称为数据报&#xff0c;由你来解包接收的数据报。DatagramSocket可以…
阅读更多...
Day57【动态规划】647.回文子串、516.最长回文子序列

Day57【动态规划】647.回文子串、516.最长回文子序列

647.回文子串 力扣题目链接/文章讲解 视频讲解 1、确定 dp 数组下标及值含义 dp[i][j]&#xff1a;表示区间范围为 [i, j] 的子串是否为回文串&#xff08;j > i&#xff09; 这样定义才方便我们的递推&#xff01;怎么想到的&#xff1f;回文串需要对比串的两端&#…
阅读更多...
用可编程逻辑器件FPGA LCMXO2-4000HC-6MG132I 实现智能汽车解决方案设计

用可编程逻辑器件FPGA LCMXO2-4000HC-6MG132I 实现智能汽车解决方案设计

LCMXO2-4000HC-6MG132I lattice莱迪斯深力科 MachXO2 可编程逻辑器件 (PLD) 由六个超低功耗、即时启动、非易失性 PLD 组成&#xff0c;可提供 256 至 6864 个查找表 (LUT) 的密度。 MachXO2 系列 PLD 提供多种特性&#xff0c;例如嵌入式块 RAM (EBR)、分布式 RAM 和用户闪存 …
阅读更多...
最新文章

Copyright @ 2022~2023