C++STL——list容器及其常用操作(详解)

这篇具有很好参考价值的文章主要介绍了C++STL——list容器及其常用操作(详解)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记
纵有疾风起,人生不言弃。本文篇幅较长,如有错误请不吝赐教,感谢支持。

一.list容器基本概念

链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。
每个结点包括两个部分:

  • 一个是存储数据元素的数据域。
  • 另一个是存储下一个结点地址的指针域。
    C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记

list容器的数据结构是一个有头双向循环链表。链表其优缺点为:

  • 采用动态存储分配,不会造成内存浪费和溢出
  • 链表执行插入和删除操作十分方便,修改指针即可,不需要移动大量元素
  • 链表灵活,但是空间和时间额外耗费较大

list容器的迭代器:
list容器不能像vector一样以普通指针作为迭代器,因为其节点不能保证在同一块连续的内存空间上。list迭代器必须有能力指向list的节点,并有能力进行正确的递增、递减、取值、成员存取操作。所谓”list正确的递增,递减、取值、成员取用”是指,递增时指向下一个节点,递减时指向上一个节点,取值时取的是节点的数据值,成员取用时取的是节点的成员。由于list还是一个双向链表,迭代器必须能够具备前移、后移的能力,所以list容器提供的是双向迭代器(Bidirectional Iterators).
C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记

二.list容器的常用操作

list构造函数

注:使用list容器时,需包含头文件#include <list>

函数原型 解释
list <T> lst; list采用模板实现类实现(显示实例化),对象的默认构造形式。
list(beg,end); 构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem); 构造函数将n个elem拷贝给本身。
list(const list &lst); 拷贝构造函数。

实例:构造函数演示

#include <iostream>
using namespace std;
#include <list>//包含头文件
void printList(const list<int>& mylist)//形参使用const,避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test()
{
	list<char> mylist1;//list采用模板实现类实现(显示实例化),对象的默认构造形式。
	list<int> mylist2(10, 6); //构造函数将n个elem拷贝给本身。
	list<int> mylist3(++mylist2.begin(), --mylist2.end());//构造函数将[beg, end)区间中的元素拷贝给本身。
	list<int> mylist4(mylist2);//拷贝构造函数

	printList(mylist2);
	printList(mylist3);
	printList(mylist4);
}
int main()
{
	test();
	return 0;
}

C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记

list迭代器获取

C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记

获取正向迭代器iterator:

函数原型 解释
iterator begin(); 返回指向开始位置的迭代器,iterator是正向迭代器。只能使用++运算符从左向右遍历容器,每次沿容器向右移动一个元素
const_iterator begin(); 返回指向开始位置并且为常量的迭代器
const_iterator cbegin(); 返回指向开始并且为常量的迭代器,const_iterator 常正向迭代器。函数作用:配合auto使用
iterator end(); 返回指向末尾元素的下一个位置的迭代器
const_iterator end(); 返回指向末尾元素的下一个位置并且为常量的迭代器
const_iterator cend(); 返回指向末尾元素的下一个位置的并且为常量的迭代器,函数作用:配合auto使用

获取反向迭代器reverse_iterator:

函数原型 解释
reverse_iterator rbegin(); 返回反向迭代器,指向末尾元素下一个位置,操作都是往相反反向,reverse_iterator 为反向迭代器
const_reverse_iterator crbegin(); 返回反向迭代器,指向末尾元素下一个位置,操作都是往相反反向,并且为常量属性,const_reverse_iterator 常反向迭代器。
reverse_iterator rend(); 返回反向迭代器,指向开头元素的位置,操作都是往相反反向
const_reverse_iterator cre nd(); 返回反向迭代器,指向开头元素的位置,操作都是往相反反向,并且为常量属性

迭代器都可以进行++操作。反向迭代器和正向迭代器的区别在于:
对正向迭代器进行++操作时,迭代器会指向容器中的后一个元素;
而对反向迭代器进行++操作时,迭代器会指向容器中的前一个元素。

#include <iostream>
using namespace std;
#include <list>//包含头文件
void printList1(const list<int>& mylist)//形参使用const,避免被修改
{//const_iterator只读迭代器
	for (auto it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << "|";
	}
	cout << endl;
}
void printList2(const list<int>& mylist)//形参使用const,避免被修改
{//const_iterator只读迭代器
	for (auto it = mylist.rbegin(); it != mylist.rend(); ++it)
	{
		cout << *it << "|";
	}
	cout << endl;
}
void test()
{
	list<int> mylist;
	for (int i = 0; i < 5; i++)
	{
		mylist.push_back(i + 1);//1 2 3 4 5
	}
	printList1(mylist);
	printList2(mylist);
}
int main()
{
	test();
	return 0;
}

C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记

注意:begin函数和cbegin函数都可以返回const_iterator,那么为什么要两个函数呢?
因为begin函数有重载,无法配合auto(自动推导数据类型)使用,所以才多出一个cbegin函数。

list特性操作

函数原型 解释
size_t size() const; 返回容器的实际大小(已使用的空间)。
bool empty() const; 判断容器是否为空。
void clear(); 清空容器。
void resize(size_t size); 把容器的实际大小置为size,如果size<实际大小,会截断多出的部分;如果size>实际大小,则以默认值0填充新位置
void resize(size_t size,const T &value); 把容器的实际大小置为size,如果size<实际大小,会截断多出的部分;如果size>实际大小,就用value填充。

实例:特性函数演示

#include <iostream>
using namespace std;
#include <list>//包含头文件
void printList(const list<int>& mylist)//形参使用const,避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test()
{
	list<int> mylist;
	for (int i = 0; i < 5; i++)
	{
		mylist.push_back(i + 1);
	}

	cout << "size:" << mylist.size() << endl;//5

	cout << mylist.empty() << endl;//0
	if (mylist.empty())
	{
		cout << "空" << endl;
	}
	else
	{
		cout << "不为空" << endl;
	}

	mylist.resize(3);
	printList(mylist);//1 2 3

	mylist.resize(5);//重新指定容器的长度为num,若容器变长,则以默认值填充新位置。
	printList(mylist);//1 2 3 0 0

	mylist .resize(10, 6);//如果容器变长,也可以用value填充
	printList(mylist);//1 2 3 0 0 6 6 6 6 6 
}
int main()
{
	test();
	return 0;
}

C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记

list元素操作

函数原型 解释
T& front(); 返回第一个元素。
T& back(); 返回最后一个元素。

list赋值操作

作用:通过重载赋值运算符operator=和成员函数assign(),给已存在的容器赋值,将覆盖容器中原有的内容。

函数原型 解释
list assign(beg, end); 将[beg, end)区间中的数据拷贝赋值给本身。
void assign(const size_t n, const T& value); 将n个elem拷贝赋值给本身。
list& operator=(const list &lst); 重载等号操作符,把容器l赋值给当前容器。

实例:赋值操作演示

#include <iostream>
using namespace std;
#include <list>//包含头文件
#include<algorithm>
void printList(const list<int>& mylist)//形参使用const,避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	list<int> mylist;
	mylist.assign(10, 10);
	printList(mylist);

	list<int> mylist2;
	mylist2.assign(mylist.begin()++, mylist.end()--);
	printList(mylist2);

	cout << mylist.front() << endl;
	cout << mylist.back() << endl;
}
int main()
{
	test();
	return 0;
}

C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记

list的交换、反转、排序、归并操作

函数原型 解释
void swap(list<T> &l); 把当前容器与l交换,交换的是链表结点的地址。
void reverse(); 反转链表。
void sort(); 对容器中的元素进行升序排序。
void sort(_Pr2 _Pred); 对容器中的元素进行排序,排序的方法由_Pred决定(二元函数)。
void merge(list< T> &l); 采用归并法合并两个已排序的list容器,合并后的list容器仍是有序的。

实例:list的交换、反转、排序、归并操作演示

#include <iostream>
using namespace std;
#include <list>//包含头文件
#include<algorithm>
void printList(const list<int>& mylist)//形参使用const,避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
bool myfunc2(int v1, int v2)
{
	return v1 > v2;
}
void test()
{
	list<int> mylist;
	for (int i = 0; i < 5; i++)
	{
		mylist.push_back(i + 10);//10 11 12 13 14
	}
	list<int> mylist2;
	for (int i = 0; i < 5; i++)
	{
		mylist2.push_back(i);//0 1 2 3 4
	}

	mylist2.swap(mylist); //把当前容器mylist2与mylist交换,交换的是链表结点的地址。
	printList(mylist2);//10 11 12 13 14

	mylist2.reverse();//反转链表

	printList(mylist2);//14 13 12 11 10

	//注意:list容器不能使用sort算法,list容器有自己专属的sort成员函数
	//sort(mylist.begin(), mylist.end());
	
	mylist2.sort(myfunc2);//借助myfunc2函数进行比较,然后sort降序排列
	printList(mylist2);//14 13 12 11 10

	mylist2.sort();//mylist2链表使用sort函数默认升序排列
	printList(mylist2);//10 11 12 13 14

	mylist.sort();//mylist链表使用sort函数默认升序排列
	printList(mylist);//0 1 2 3 4 

	mylist2.merge(mylist); //采用归并法合并两个已排序的list容器,合并后的list容器仍是有序的
	printList(mylist2); //0 1 2 3 4 10 11 12 13 14

}
int main()
{
	test();
	return 0;
}

C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记

list比较操作

函数原型 解释
bool operator == (const vector<T> & l) const; 重载==运算符,判断当前链表与l是否相等
bool operator != (const vector<T> & l) const; 重载!=运算符,判断当前链表与l是否不相等

list插入和删除操作

函数原型 解释
void push_front(const T& ele); 在容器头部插入一个数据
void push_back(const T& ele); 尾部插入元素ele
void pop_front(); 删除容器第一个数据
void pop_back(); 删除最后一个元素
iterator insert(iterator pos, const T& value); 在指定位置插入一个元素,返回指向插入元素的迭代器。
iterator insert(pos,n,elem); 在pos位置插入n个elem数据,返回指向第一个插入元素的迭代器。
iterator insert(iterator pos, iterator first, iterator last); 在指定位置插入一个区间的元素,返回指向第一个插入元素的迭代器。
iterator erase(iterator pos); 删除指定位置的元素,返回下一个有效的迭代器。
iterator erase(iterator first, iterator last); 删除指定区间的元素,返回下一个有效的迭代器。
splice(iterator pos, const vector< T> & l); 把另一个链表连接到当前链表pos位置处。
splice(iterator pos, const vector< T> & l, iterator first, iterator last); 把另一个链表指定的区间连接到当前链表pos位置处。
splice(iterator pos, const vector< T> & l, iterator first); 把另一个链表从first开始的结点连接到当前链表pos位置处。
void remove(const T& value); 删除链表中所有值等于value的元素。
void remove_if(_Pr1 _Pred); 删除链表中满足条件的元素,参数_Pred是一元函数。
void unique(); 删除链表中相邻的重复元素,只保留一个。

list插入和删除操作演示:

#include <iostream>
using namespace std;
#include <vector>
#include <list>//包含头文件
void printList(const list<int>& mylist)//形参使用const,避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
bool myfunc(int val)
{
	return val > 300;
}
void test()
{
	list<int> mylist;
	mylist.push_back(10);//在容器尾部插入一个数据
	mylist.push_back(20);
	mylist.push_back(30);
	mylist.push_back(40);
	mylist.push_back(50);
	
	mylist.push_front(100);//在容器头部插入一个数据
	mylist.push_front(200);
	mylist.push_front(300);
	mylist.push_front(400);

	printList(mylist);//400 300 200 100 10 20 30 40 50
	cout << "------------------" << endl;

	list<int>::const_iterator it = mylist.insert(mylist.begin(), 2, 0);//在pos位置插入n个elem数据
	cout << *it << endl;//返回指向第一个插入元素的迭代器。
	cout << "------------------" << endl;

	vector<int> v;
	v.push_back(1000);
	v.push_back(2000);
	v.push_back(3000);

	mylist.insert(mylist.begin(), v.begin(), v.end()); //在指定位置插入一个区间的元素,返回指向第一个插入元素的迭代器
	printList(mylist);//1000 2000 3000 400 300 200 100 10 20 30 40 50
	cout << "------------------" << endl;

	mylist.erase(mylist.begin());//删除第一个元素
	printList(mylist); //2000 3000 400 300 200 100 10 20 30 40 50
	cout << "------------------" << endl;

	list<int> mylist2(6,6);

	mylist.splice(mylist.end(),mylist2);//将mylist2链接到mylist后
	printList(mylist);//2000 3000 400 300 200 100 10 20 30 40 50 6 6 6 6 6 6
	cout << "------------------" << endl;

	mylist.remove(300); //删除链表中所有值等于300的元素
	printList(mylist);//2000 3000 400 200 100 10 20 30 40 50 6 6 6 6 6 6
	cout << "------------------" << endl;

	mylist.remove_if(myfunc);//删除链表中所有值大于300的元素
	printList(mylist);// 200 100 10 20 30 40 50 6 6 6 6 6 6
	cout << "------------------" << endl;
}
int main()
{
	test();
	return 0;
}

C++STL——list容器及其常用操作(详解),C++核心编程,c++,list,学习,数据结构,笔记文章来源地址https://www.toymoban.com/news/detail-623802.html

到了这里,关于C++STL——list容器及其常用操作(详解)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • STL——stack容器、queue容器、list容器

    就是栈 栈不允许有遍历行为 是先进后出的数据结构 是先进先出的数据结构 **队列容器允许从一端新增元素,从另一端移除元素 队列中只有队头和队尾才可以被外界使用,因此队列不允许有遍历行为 队列中进数据称为—入队push 队列中出数据称为—出队pop ** 在STL中这个链表

    2024年02月09日
    浏览(36)
  • 【C++STL】list的使用及其模拟实现

    list和sting、vector一样,我们可以使用cplusplus文档进行查询:list的文档介绍 【总结】 1.list是可以在常数范围内在任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代 2.list的底层是双向链表结构,双向链表中每个元素存储在互不相关的独立节点中,在节点中通

    2023年04月19日
    浏览(59)
  • 【C++学习】STL容器——list

    目录 一、list的介绍及使用 1.1 list的介绍  1.2 list的使用 1.2.1 list的构造  1.2.2  list iterator的使用 1.2.3 list capacity 1.2.4 list element access 1.2.5 list modifiers 1.2.6 list 迭代器失效 二、list的模拟实现 2.1 模拟实现list 三、list和vector的对比 一、list的介绍及使用 1.1 list的介绍 list的文档介绍

    2024年02月14日
    浏览(38)
  • 【C++STL精讲】list的使用教程及其模拟实现

    🌸作者简介: 花想云 ,在读本科生一枚,致力于 C/C++、Linux 学习。 🌸 本文收录于 C++系列 ,本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等,专为大学生打造全套 C++ 学习教程,持续更新! 🌸 相关专栏推荐: C语言初阶系列 、 C语言进阶系列 、 数据结构与算法 本章我们

    2023年04月25日
    浏览(42)
  • C++ ——STL容器【list】模拟实现

    代码仓库: list模拟实现 list源码 数据结构——双向链表 源码的list是双向带头循环链表,所以我们定义两个节点,一个指向下一个,一个指向前一个 list类包含一个 _head 头节点,然后为了方便查出当前有多少个节点,还能多定义一个 _size 源码的迭代器设置了三个模板参数:

    2024年02月15日
    浏览(44)
  • 【STL】“list“容器从使用到模拟实现

    🎉博客主页:小智_x0___0x_ 🎉欢迎关注:👍点赞🙌收藏✍️留言 🎉系列专栏:C++初阶 🎉代码仓库:小智的代码仓库 list是可以在常数范围内在任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代。 list的底层是 双向链表结构 ,双向链表中每个元素存储在

    2024年02月16日
    浏览(70)
  • STL容器 -- list的模拟实现(配详细注释)

    C++ STL(Standard Template Library,标准模板库)提供了一组通用的模板类和函数,用于实现常用的数据结构和算法。其中之一是 std::list,它实现了一个双向链表。 std::list 是一个容器,用于存储一系列的值。与数组和向量等连续存储的容器不同,std::list 使用链表作为底层数据结构

    2024年02月16日
    浏览(48)
  • 【C++】STL之list容器的模拟实现

    个人主页:🍝在肯德基吃麻辣烫 分享一句喜欢的话:热烈的火焰,冰封在最沉默的火山深处。 本文章进入C++STL之list的模拟实现。 在STL标准库实现的list中,这个链表是一个== 双向带头循环链表==。 说明: list是一个类,成员变量为_head 节点类node,是每一个节点。 list的迭代

    2024年02月17日
    浏览(52)
  • C++ stl容器list的底层模拟实现

    目录 前言: 1.创建节点 2.普通迭代器的封装 3.反向迭代器的封装 为什么要对正向迭代器进行封装? 4.const迭代器 5.构造函数 6.拷贝构造 7.赋值重载 8.insert 9.erase 10.析构 11.头插头删,尾插尾删 12.完整代码+简单测试 总结: 1.创建节点 注意给缺省值,这样全缺省就会被当做默认

    2024年04月23日
    浏览(44)
  • 【C++STL标准库】序列容器之deuqe与、orwa_list与list

    基本概念这里就不再浪费时间去解释,这里给出deuqe与、orwa_list、list的基本使用方法: deque队列: forward_list单向列表: list双向链表: 如果发现文章中有错误,还请大家指出来,我会非常虚心地学习,我们一起进步!!!

    2024年02月15日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包