AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【C++ STL】 --- list

2023-07-10 64
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【C++ STL】 --- list

1、list基本概念

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

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

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

list的优点：

采用动态存储分配，不会造成内存浪费和溢出

链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

链表灵活，但是空间(指针域) 和 时间（遍历）额外耗费较大

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

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

2、list构造函数

功能描述：

创建list容器

函数原型：

1. list<T> lst;           //list采用采用模板类实现,对象的默认构造形式：
2. list(beg,end);         //构造函数将[beg, end)区间中的元素拷贝给本身。
3. list(n,elem);          //构造函数将n个elem拷贝给本身。
4. list(const list &lst); //拷贝构造函数
1. void printList(const list<int>& L) {
2. 
3.  for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
4.    cout << *it << " ";
5.  }
6.  cout << endl;
7. }
8. 
9. void test01()
10. {
11.   list<int>L1;
12.   L1.push_back(10);
13.   L1.push_back(20);
14.   L1.push_back(30);
15.   L1.push_back(40);
16. 
17.   printList(L1);
18. 
19.   list<int>L2(L1.begin(),L1.end());
20.   printList(L2);
21. 
22.   list<int>L3(L2);
23.   printList(L3);
24. 
25.   list<int>L4(10, 1000);
26.   printList(L4);
27. }
28. 
29. int main() 
30. {
31.   test01();
32.   return 0;
33. }

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

3、list 赋值和交换

功能描述：

给list容器进行赋值，以及交换list容器

函数原型：

1. assign(beg, end);                    //将[beg, end)区间中的数据拷贝赋值给本身。
2. assign(n, elem);                     //将n个elem拷贝赋值给本身。
3. list& operator=(const list &lst);    //重载等号操作符
4. swap(lst);                           //将lst与本身的元素互换
1. void printList(const list<int>& L) {
2. 
3.  for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
4.    cout << *it << " ";
5.  }
6.  cout << endl;
7. }
8. 
9. //赋值和交换
10. void test01()
11. {
12.   list<int>L1;
13.   L1.push_back(10);
14.   L1.push_back(20);
15.   L1.push_back(30);
16.   L1.push_back(40);
17.   printList(L1);
18. 
19.   //赋值
20.   list<int>L2;
21.   L2 = L1;
22.   printList(L2);
23. 
24.   list<int>L3;
25.   L3.assign(L2.begin(), L2.end());
26.   printList(L3);
27. 
28.   list<int>L4;
29.   L4.assign(10, 100);
30.   printList(L4);
31. 
32. }
33. 
34. //交换
35. void test02()
36. {
37. 
38.   list<int>L1;
39.   L1.push_back(10);
40.   L1.push_back(20);
41.   L1.push_back(30);
42.   L1.push_back(40);
43. 
44.   list<int>L2;
45.   L2.assign(10, 100);
46. 
47.   cout << "交换前： " << endl;
48.   printList(L1);
49.   printList(L2);
50. 
51.   cout << endl;
52. 
53.   L1.swap(L2);
54. 
55.   cout << "交换后： " << endl;
56.   printList(L1);
57.   printList(L2);
58. 
59. }
60. 
61. int main() 
62. {
63.   //test01();
64.   test02();
65.   return 0;
66. }

4、list 大小操作

功能描述：

对list容器的大小进行操作

函数原型：

1. size();                 //返回容器中元素的个数
2. empty();                //判断容器是否为空
3. resize(num);            //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
4. //如果容器变短，则末尾超出容器长度的元素被删除。
5. resize(num, elem);      //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
6. //如果容器变短，则末尾超出容器长度的元素被删除
1. void printList(const list<int>& L) {
2. 
3.  for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
4.    cout << *it << " ";
5.  }
6.  cout << endl;
7. }
8. 
9. //大小操作
10. void test01()
11. {
12.   list<int>L1;
13.   L1.push_back(10);
14.   L1.push_back(20);
15.   L1.push_back(30);
16.   L1.push_back(40);
17. 
18.   if (L1.empty())
19.   {
20.     cout << "L1为空" << endl;
21.   }
22.   else
23.   {
24.     cout << "L1不为空" << endl;
25.     cout << "L1的大小为： " << L1.size() << endl;
26.   }
27. 
28.   //重新指定大小
29.   L1.resize(10);
30.   printList(L1);
31. 
32.   L1.resize(2);
33.   printList(L1);
34. }
35. 
36. int main() 
37. {
38.   test01();
39.   return 0;
40. }

总结：

判断是否为空 --- empty

返回元素个数 --- size

重新指定个数 --- resize

5、list插入和删除

功能描述：

对list容器进行数据的插入和删除

函数原型：

1. push_back(elem);            //在容器尾部加入一个元素
2. pop_back();                 //删除容器中最后一个元素
3. push_front(elem);           //在容器开头插入一个元素
4. pop_front();                //从容器开头移除第一个元素
5. insert(pos,elem);           //在pos位置插elem元素的拷贝，返回新数据的位置
6. insert(pos,n,elem);         //在pos位置插入n个elem数据，无返回值。
7. insert(pos,beg,end);        //在pos位置插入[beg,end)区间的数据，无返回值。
8. clear();                    //移除容器的所有数据
9. erase(beg,end);             //删除[beg,end)区间的数据，返回下一个数据的位置。
10. erase(pos);                 //删除pos位置的数据，返回下一个数据的位置。
11. remove(elem);               //删除容器中所有与elem值匹配的元素
1. void printList(const list<int>& L) {
2. 
3.  for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
4.    cout << *it << " ";
5.  }
6.  cout << endl;
7. }
8. 
9. //插入和删除
10. void test01()
11. {
12.   list<int> L;
13.   //尾插
14.   L.push_back(10);
15.   L.push_back(20);
16.   L.push_back(30);
17.   //头插
18.   L.push_front(100);
19.   L.push_front(200);
20.   L.push_front(300);
21. 
22.   printList(L);
23. 
24.   //尾删
25.   L.pop_back();
26.   printList(L);
27. 
28.   //头删
29.   L.pop_front();
30.   printList(L);
31. 
32.   //插入
33.   list<int>::iterator it = L.begin();
34.   L.insert(++it, 1000);
35.   printList(L);
36. 
37.   //删除
38.   it = L.begin();
39.   L.erase(++it);
40.   printList(L);
41. 
42.   //移除
43.   L.push_back(10000);
44.   L.push_back(10000);
45.   L.push_back(10000);
46.   printList(L);
47.   L.remove(10000);
48.   printList(L);
49. 
50. //清空
51.   L.clear();
52.   printList(L);
53. }
54. 
55. int main() 
56. {
57.   test01();
58.   return 0;
59. }

总结：

* 尾插   --- push_back

* 尾删   --- pop_back

* 头插   --- push_front

* 头删   --- pop_front

* 插入   --- insert

* 删除   --- erase

* 移除   --- remove

* 清空   --- clear

6、list 数据存取

功能描述：

对list容器中数据进行存取

函数原型：

1. front(); //返回第一个元素
2. back();  //返回最后一个元素
1. //数据存取
2. void test01()
3. {
4.  list<int>L1;
5.  L1.push_back(10);
6.  L1.push_back(20);
7.  L1.push_back(30);
8.  L1.push_back(40);
9. 
10. 
11.   //cout << L1.at(0) << endl;//错误 不支持at访问数据
12.   //cout << L1[0] << endl; //错误  不支持[]方式访问数据
13.   cout << "第一个元素为： " << L1.front() << endl;
14.   cout << "最后一个元素为： " << L1.back() << endl;
15. 
16.   //list容器的迭代器是双向迭代器，不支持随机访问
17.   list<int>::iterator it = L1.begin();
18.   //it = it + 1;//错误，不可以跳跃访问，即使是+1
19. }
20. 
21. int main() 
22. {
23.   test01();
24.   return 0;
25. }

总结：

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

返回第一个元素 --- front

返回最后一个元素 --- back

7、list反转和排序

功能描述：

将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

1. reverse();      //反转链表
2. sort();         //链表排序
1. void printList(const list<int>& L) {
2. 
3.  for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
4.    cout << *it << " ";
5.  }
6.  cout << endl;
7. }
8. 
9. bool myCompare(int val1 , int val2)
10. {
11.   return val1 > val2;
12. }
13. 
14. //反转和排序
15. void test01()
16. {
17.   list<int> L;
18.   L.push_back(90);
19.   L.push_back(30);
20.   L.push_back(20);
21.   L.push_back(70);
22.   printList(L);
23. 
24.   //反转容器的元素
25.   L.reverse();
26.   printList(L);
27. 
28.   //排序
29.   L.sort(); //默认的排序规则 从小到大
30.   printList(L);
31. 
32.   L.sort(myCompare); //指定规则，从大到小
33.   printList(L);
34. }
35. 
36. int main() 
37. {
38.   test01();
39.   return 0;
40. }
文章标签：
C++
容器
存储
关键词：
C++ stl
stl List
C++ stl list
C++ list
yum9193-41641
目录
相关文章
ephemerals__
|
7天前
|
编译器 C语言 C++
【c++丨STL】list模拟实现（附源码）
本文介绍了如何模拟实现C++中的`list`容器。`list`底层采用双向带头循环链表结构，相较于`vector`和`string`更为复杂。文章首先回顾了`list`的基本结构和常用接口，然后详细讲解了节点、迭代器及容器的实现过程。 最终，通过这些步骤，我们成功模拟实现了`list`容器的功能。文章最后提供了完整的代码实现，并简要总结了实现过程中的关键点。 如果你对双向链表或`list`的底层实现感兴趣，建议先掌握相关基础知识后再阅读本文，以便更好地理解内容。
ephemerals__
15 1
ephemerals__
|
20天前
|
算法 C语言 C++
【c++丨STL】list的使用
本文介绍了STL容器`list`的使用方法及其主要功能。`list`是一种双向链表结构，适用于频繁的插入和删除操作。文章详细讲解了`list`的构造函数、析构函数、赋值重载、迭代器、容量接口、元素访问接口、增删查改操作以及一些特有的操作接口如`splice`、`remove_if`、`unique`、`merge`、`sort`和`reverse`。通过示例代码，读者可以更好地理解如何使用这些接口。最后，作者总结了`list`的特点和适用场景，并预告了后续关于`list`模拟实现的文章。
ephemerals__
34 7
蓝易云
|
28天前
|
存储 编译器 C++
C++ initializer_list&&类型推导
在 C++ 中，`initializer_list` 提供了一种方便的方式来初始化容器和传递参数，而右值引用则是实现高效资源管理和移动语义的关键特性。尽管在实际应用中 `initializer_list&&` 并不常见，但理解其类型推导和使用方式有助于深入掌握现代 C++ 的高级特性。
蓝易云
20 4
ephemerals__
|
2月前
|
存储 编译器 C语言
【c++丨STL】vector的使用
本文介绍了C++ STL中的`vector`容器，包括其基本概念、主要接口及其使用方法。`vector`是一种动态数组，能够根据需要自动调整大小，提供了丰富的操作接口，如增删查改等。文章详细解释了`vector`的构造函数、赋值运算符、容量接口、迭代器接口、元素访问接口以及一些常用的增删操作函数。最后，还展示了如何使用`vector`创建字符串数组，体现了`vector`在实际编程中的灵活性和实用性。
ephemerals__
66 4
ephemerals__
|
2月前
|
C语言 C++ 容器
【c++丨STL】string模拟实现（附源码）
本文详细介绍了如何模拟实现C++ STL中的`string`类，包括其构造函数、拷贝构造、赋值重载、析构函数等基本功能，以及字符串的插入、删除、查找、比较等操作。文章还展示了如何实现输入输出流操作符，使自定义的`string`类能够方便地与`cin`和`cout`配合使用。通过这些实现，读者不仅能加深对`string`类的理解，还能提升对C++编程技巧的掌握。
ephemerals__
81 5
ephemerals__
|
2月前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
63 2
ephemerals__
|
2月前
|
存储 算法 Linux
【c++】STL简介
本文介绍了C++标准模板库（STL）的基本概念、组成部分及学习方法，强调了STL在提高编程效率和代码复用性方面的重要性。文章详细解析了STL的六大组件：容器、算法、迭代器、仿函数、配接器和空间配置器，并提出了学习STL的三个层次，旨在帮助读者深入理解和掌握STL。
ephemerals__
61 0
ephemerals__
|
23天前
|
存储 编译器 C语言
【c++丨STL】vector模拟实现
本文深入探讨了 `vector` 的底层实现原理，并尝试模拟实现其结构及常用接口。首先介绍了 `vector` 的底层是动态顺序表，使用三个迭代器（指针）来维护数组，分别为 `start`、`finish` 和 `end_of_storage`。接着详细讲解了如何实现 `vector` 的各种构造函数、析构函数、容量接口、迭代器接口、插入和删除操作等。最后提供了完整的模拟实现代码，帮助读者更好地理解和掌握 `vector` 的实现细节。
ephemerals__
31 0
ephemerals__
|
2月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
113 5
ephemerals__
|
2月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
112 4