C++提高编程（三）—— STL常用容器(7) ：list容器

7. list容器7.1 list基本概念7.2list构造函数7.3 list 赋值和交换7.4 list 大小操作7.5 list 插入和删除7.6 list 数据存取7.7 list 反转和排序7.8 排序案例7. list容器7.1 list基本概念功能：将数据进行链式存储。链表(list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。

大彤小忆

3499人浏览 · 2021-04-13 21:23:15

大彤小忆 · 2021-04-13 21:23:15 发布

C++系列内容的学习目录 $\rightarrow$ C++学习系列内容汇总。

7. list容器

7. list容器

7.1 list基本概念

功能： 将数据进行链式存储。

链表(list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。

链表的组成： 链表由一系列结点组成。
结点的组成： 一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

STL中的链表是一个双向循环链表，如下图所示。

在这里插入图片描述
由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。

list的优点： 1. 采用动态存储分配，不会造成内存浪费和溢出；
2. 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。

list的缺点：链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大，遍历速度没有数组快，且占用空间比数组大。

list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

总结： STL中list和vector是两个最常被使用的容器，各有优缺点。

7.2 list构造函数

功能描述： 创建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>

//list容器构造函数

void printList(const list<int>&L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	//创建list容器
	list<int>L1;  //默认构造

	//添加数据
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	//遍历容器
	printList(L1);

	//区间构造方式
	list<int>L2(L1.begin(), L1.end());
	printList(L2);

	//拷贝构造
	list<int>L3(L2);
	printList(L3);

	//n个elem
	list<int>L4(5, 1000);
	printList(L4);
}

int main()
{
	test01();

	system("pause");

	return 0;
}

10 20 30 40
10 20 30 40
10 20 30 40
1000 1000 1000 1000 1000

总结： list构造方式同其他几个STL常用容器，熟练掌握即可。

7.3 list赋值和交换

功能描述： 给list容器进行赋值，以及交换list容器。

函数原型：

assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem); //将n个elem拷贝赋值给本身
list& operator=(const list &lst); //重载等号操作符
swap(lst); //将lst与本身的元素互换

实例如下所示。

#include<iostream>
using namespace std;
#include<list>

//list容器赋值和交换

void printList(const list<int>&L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//赋值
void test01()
{
	list<int>L1; 
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);

	list<int>L2;
	L2 = L1;  //operator=赋值
	printList(L2);

	list<int>L3;
	L3.assign(L2.begin(), L2.end());  //将[beg, end)区间中的数据拷贝赋值给本身
	printList(L3);

	list<int>L4;
	L4.assign(10, 100);  将n个elem拷贝赋值给本身
	printList(L4);
}

//交换
void test02()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	list<int>L2;
	L2.assign(10, 100);

	cout << "交换前：" << endl;
	printList(L1);
	printList(L2);

	L1.swap(L2);
	cout << "交换后：" << endl;
	printList(L1);
	printList(L2);
}

int main()
{
	test01();
	test02();

	system("pause");

	return 0;
}

10 20 30 40
10 20 30 40
10 20 30 40
100 100 100 100 100 100 100 100 100 100
交换前：
10 20 30 40
100 100 100 100 100 100 100 100 100 100
交换后：
100 100 100 100 100 100 100 100 100 100
10 20 30 40

总结： list赋值和交换操作能够灵活运用即可。

7.4 list大小操作

功能描述： 对list容器的大小进行操作。

函数原型：

size(); //返回容器中元素的个数
empty(); //判断容器是否为空
resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
//如果容器变短，则末尾超出容器长度的元素被删除
resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置
//如果容器变短，则末尾超出容器长度的元素被删除

实例如下所示。

#include<iostream>
using namespace std;
#include<list>

//list大小操作

void printList(const list<int>&L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	printList(L1);

	//判断容器是否为空
	if (L1.empty())
	{
		cout << "L1为空！" << endl;
	}
	else
	{
		cout << "L1不为空！" << endl;
		cout << "L1的元素个数为：" << L1.size() << endl;
	}
	//重新指定大小
	L1.resize(10, 10000);
	printList(L1);

	L1.resize(2);
	printList(L1);
}

int main()
{
	test01();

	system("pause");

	return 0;
}

10 20 30 40
L1不为空！
L1的元素个数为：4
10 20 30 40 10000 10000 10000 10000 10000 10000
10 20

7.5 list插入和删除

功能描述： 对list容器进行数据的插入和删除。

函数原型：

push_back(elem); //在容器尾部加入一个元素（尾插）
pop_back(); //删除容器中最后一个元素（尾删）
push_front(elem); //在容器开头插入一个元素（头插）
pop_front(); //从容器开头移除第一个元素（头删）
insert(pos,elem); //在pos位置插elem元素的拷贝，返回新数据的位置
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值
insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值
clear(); //移除容器的所有数据
erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置
erase(pos); //删除pos位置的数据，返回下一个数据的位置
remove(elem); //删除容器中所有与elem值匹配的元素

实例如下所示。

#include<iostream>
using namespace std;
#include<list>

//list插入和删除

void printList(const list<int>&L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L;
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);

	//头插
	L.push_front(100); 
	L.push_front(200);
	L.push_front(300);

	printList(L);  //300 200 100 10 20 30

	//尾删
	L.pop_back();
	printList(L);  //300 200 100 10 20

	//头删
	L.pop_front();
	printList(L);  //200 100 10 20

	//insert插入
	L.insert(L.begin(),1000);
	printList(L);  //1000 200 100 10 20

	list<int>::iterator it = L.begin();
	L.insert(++it, 20000);
	printList(L);  //1000 20000 200 100 10 20 

	//删除
	it = L.begin();
	L.erase(++it);
	printList(L);  //1000 200 100 10 20

	//移除
	L.push_back(10000);
	L.push_back(10000); 
	L.push_back(10000);
	printList(L);  //1000 200 100 10 20 10000 10000 10000
	L.remove(10000);  //删除容器中所有与10000值匹配的元素
	printList(L);  //1000 200 100 10 20

	//清空
	L.clear();
	printList(L);  //打印一行空格
}

int main()
{
	test01();

	system("pause");

	return 0;
}

300 200 100 10 20 30
300 200 100 10 20
200 100 10 20
1000 200 100 10 20
1000 20000 200 100 10 20
1000 200 100 10 20
1000 200 100 10 20 10000 10000 10000
1000 200 100 10 20

请按任意键继续. . .

7.6 list数据存取

功能描述： 对list容器中数据进行存取。

函数原型：

front(); //返回第一个元素
back(); //返回最后一个元素

实例如下所示。

#include<iostream>
using namespace std;
#include<list>

//list数据存取
void test01()
{
	list<int>L1;

	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	//L1[0];  //错误，不可以用[]访问list容器中的元素
	//L1.at(0);  //错误，不可以用at访问list容器中的元素
	//上述两种方式均不能访问list容器中的元素的原因是list本质是链表，不是用连续线性空间访问存储数据，迭代器也是不支持随机访问的

	cout << "第一个元素为：" << L1.front() << endl;
	cout << "最后一个元素为：" << L1.back() << endl;

	//验证迭代器不支持随机访问
	list<int>::iterator it = L1.begin();

	it++;  //支持双向
	it--;
	//it = it + 1;  //错误，不支持随机访问
}

int main()
{
	test01();

	system("pause");

	return 0;
}

第一个元素为：10
最后一个元素为：40

总结： list容器中不可以通过[]或者at方式访问数据。

7.7 list反转和排序

功能描述： 将容器中的元素反转，以及将容器中的数据进行排序。

函数原型：

reverse(); //反转链表
sort(); //链表排序

实例如下所示。

#include<iostream>
using namespace std;
#include<list>

//list反转和排序

void printList(const list<int>&L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L1;

	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	cout << "反转前：" << endl;
	printList(L1);
	L1.reverse();  // 反转
	cout << "反转后：" << endl;
	printList(L1);
}

bool myCompare(int v1, int v2)
{
	//降序：让第一个数大于第二个数
	return v1 > v2;
}

void test02()
{
	list<int>L1;

	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	cout << "排序前：" << endl;
	printList(L1);

	//sort(L1.begin(), L1.end());  //错误，所有不支持随机访问迭代器的容器，不可以用标准算法，但其内部会提供对应一些算法
	L1.sort();  // 排序：默认排序规则是从小到大，即升序
	cout << "排序后：" << endl;
	printList(L1);

	L1.sort(myCompare);  //降序
	printList(L1);
}

int main()
{
	test01();
	test02();

	system("pause");

	return 0;
}

反转前：
20 10 50 40 30
反转后：
30 40 50 10 20
排序前：
20 10 50 40 30
排序后：
10 20 30 40 50
50 40 30 20 10

7.8 排序案例

案例描述： 将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高。排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序。

案例的代码如下所示。

#include<iostream>
using namespace std;
#include<list>
#include<string>

//list排序案例：对于自定义的数据类型进行排序
//按照年龄进行升序，如果年龄相同，则按照身高进行降序

class Person
{
public:
	Person(string name, int age, int height)
	{
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
	}
	string m_Name;
	int m_Age;
	int m_Height;
};

//指定排序规则
bool comparePerson(Person &p1, Person &p2)
{
	//按照年龄升序
	if (p1.m_Age == p2.m_Age)
	{
		return p1.m_Height > p2.m_Height;
	}
	else
	{
		return p1.m_Age < p2.m_Age;
	}
}

void test01()
{
	//创建容器
	list<Person>L;

	//准备数据
	Person p1("刘备", 35, 175);
	Person p2("曹操", 45, 180);
	Person p3("孙权", 40, 170);
	Person p4("赵云", 25, 190);
	Person p5("张飞", 35, 160);
	Person p6("关羽", 35, 200);

	//插入数据
	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
	{
		cout << "姓名：" << (*it).m_Name << "    年龄：" << (*it).m_Age << "    身高：" << (*it).m_Height << endl;
	}

	//排序
	cout << "------------------------------------" << endl;
	cout << "排序后：" << endl;
	L.sort(comparePerson);
	for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
	{
		cout << "姓名：" << (*it).m_Name << "    年龄：" << (*it).m_Age << "    身高：" << (*it).m_Height << endl;
	}
}

int main()
{
	test01();

	system("pause");

	return 0;
}

测试效果如下所示。

在这里插入图片描述
总结： 1. 对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序；
2. 高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂。

7.9 总结

在这里插入图片描述

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...