【C++ | STL】std::list＜T＞ 详细介绍以及例子代码(很全很详细)

😁博客主页😁：🚀https://blog.csdn.net/wkd_007🚀
🤑博客内容🤑：🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭
⏰发布时间⏰： 2024-09-24 09:10:24

本文未经允许，不得转发！！！

---

🎄一、概述

std::list是 C++ 标准模板库（STL）中的一个容器类，它以双向链表的形式存储元素。与其他序列容器（如vector）相比，list具有一些独特的优势，例如在任意位置进行插入和删除操作的效率较高，因为它不需要像vector那样移动大量元素。list中的元素在内存中不是连续存储的，而是通过指针相互链接，这使得其在某些特定场景下表现出色，例如频繁的元素插入和删除操作，以及需要在容器中间频繁进行迭代的情况。

注意：C++中使用std::list时需要包含头文件#include <list> 。

---

🎄二、增加、组合、拼接 字符串

✨2.1 构造链表

std::list 的构造函数有下面几个：

explicit list (const allocator_type& alloc = allocator_type());
explicit list (size_type n);         
list (size_type n, const value_type& val, const allocator_type& alloc = allocator_type());
template <class InputIterator>  list (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
list (const list& x);
list (const list& x, const allocator_type& alloc);
list (list&& x);
list (list&& x, const allocator_type& alloc);
list (initializer_list<value_type> il, const allocator_type& alloc = allocator_type());

构造函数常见的三种用法：

• 默认构造函数：list<T> lst; 创建一个空的list，其中T是元素类型。例如：std::list<int> myList; 创建了一个空的存储整数的list。
• 带参数的构造函数：list<T> lst(n, value); 创建一个包含n个元素，每个元素初始化为value的list。例如：std::list<double> anotherList(5, 3.14); 创建了一个包含 5 个3.14的double类型list。
• 迭代器区间构造函数：list<T> lst(first, last); 使用迭代器区间[first, last)中的元素来初始化list。例如：

  std::vector<int> vec = {1, 2, 3, 4, 5};
  std::list<int> listFromVec(vec.begin() + 1, vec.end() - 1); 
  // 创建一个包含vec中[2, 4)元素的list，即{2, 3}
  

🌰接着看例子：

// 1.1 构造函数
// constructors used in the same order as described above:
std::list<int> first;                                // empty list of ints
std::list<int> second (4,100);                       // four ints with value 100
std::list<int> third (second.begin(),second.end());  // iterating through second
std::list<int> fourth (third);                       // a copy of third

// the iterator constructor can also be used to construct from arrays:
int myints[] = {16,2,77,29};
std::list<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

std::cout << "The contents of fifth are: ";
for (std::list<int>::iterator it = fifth.begin(); it != fifth.end(); it++)
	std::cout << *it << ' ';
std::cout << '\n';

🎯运行结果：

---

✨2.2 给 std::list 对象 赋值

如果实例化一个 std::list 对象后，可以使用 = 运算符给该对象赋值，函数原型如下：

list& operator= (const list& x);
list& operator= (list&& x);
list& operator= (initializer_list<value_type> il);

operator=的功能是将新内容分配给容器，替换其当前内容，并相应地修改其大小。
🌰举例子：

// 2.2 operator=
std::list<int> ope_first (3);      // list of 3 zero-initialized ints
std::list<int> ope_second (5);     // list of 5 zero-initialized ints
ope_second = ope_first;
ope_first = std::list<int>();
std::cout << "Size of ope_first: " << int (ope_first.size()) << '\n';
std::cout << "Size of ope_second: " << int (ope_second.size()) << '\n';

🎯运行结果：

---

✨2.3 添加元素到 std::list 对象尾部

添加元素到 std::list 对象尾部主要有两个成员函数：

• push_back：在list容器当前最后一个元素之后添加一个新元素。val的内容被复制（或移动）到新元素中。
  这有效地将容器size增加了1。
• emplace_back：在list容器当前最后一个元素之后添加一个新元素。这个新元素是使用参数args作为其构造的参数来构造的。
  这有效地将容器size增加了1。

相关函数原型如下：

void push_back (const value_type& val);
void push_back (value_type&& val);

template <class... Args>  void emplace_back (Args&&... args);

🌰举例子：

// 2.3 添加元素到尾部
// push_back
std::list<int> list_push_back;
list_push_back.push_back(55);
list_push_back.push_back(66);
list_push_back.push_back(77);
std::cout << "list_push_back contains:";
for (auto& x: list_push_back)
	std::cout << " (" << x << ")";
std::cout << std::endl;	
// emplace_back
std::list< std::pair<int,char> > list_emplace;
list_emplace.emplace_back(10,'a');
list_emplace.emplace_back(20,'b');
list_emplace.emplace_back(30,'c');
std::cout << "list_emplace contains:";
for (auto& x: list_emplace)
	std::cout << " (" << x.first << "," << x.second << ")";
std::cout << std::endl;

🎯运行结果：

---

✨2.4 添加元素到 std::list 对象开头

添加元素到 std::list 对象尾部主要有两个成员函数，与上个小节形成对应的。不过多阐述，直接看例子。

void push_front (const value_type& val);
void push_front (value_type&& val);

template <class... Args>  void emplace_front (Args&&... args);

🌰举例子：

// 2.4 添加元素到开头
// push_front
std::list<int> list_push_front;
list_push_front.push_front(55);
list_push_front.push_front(66);
list_push_front.push_front(77);
std::cout << "list_push_front contains:";
for (auto& x: list_push_front)
	std::cout << " (" << x << ")";
std::cout << std::endl;	
// emplace_front
std::list< std::pair<int,char> > list_emplace_front;
list_emplace_front.emplace_front(10,'a');
list_emplace_front.emplace_front(20,'b');
list_emplace_front.emplace_front(30,'c');
std::cout << "list_emplace_front contains:";
for (auto& x: list_emplace_front)
	std::cout << " (" << x.first << "," << x.second << ")";
std::cout << std::endl;

🎯运行结果：

---

✨2.5 添加元素到 std::list 对象指定位置

// 插入到指定位置
iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, size_type n, const value_type& val);
template <class InputIterator>iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, initializer_list<value_type> il);

🌰举例子：

// 2.5 添加元素到指定位置
std::list<int> list_insert;
std::list<int>::iterator it;

// set some initial values:
for (int i=1; i<=5; ++i) list_insert.push_back(i); // 1 2 3 4 5
it = list_insert.begin();
++it;            // it points now to number 2           ^

list_insert.insert (it,10);                        // 1 10 2 3 4 5
	 // "it" still points to number 2                      ^
list_insert.insert (it,2,20);                      // 1 10 20 20 2 3 4 5
--it;            // it points now to the second 20            ^

std::vector<int> myvector (2,30);
list_insert.insert (it,myvector.begin(),myvector.end());
											// 1 10 20 30 30 20 2 3 4 5
											//               ^
std::cout << "list_insert contains:";
for (it=list_insert.begin(); it!=list_insert.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';

🎯运行结果：

---

✨2.6 其他添加到list的方式

assign函数：将新内容分配给列表容器，替换其当前内容，并相应地修改其大小。

template <class InputIterator>  void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);
void assign (initializer_list<value_type> il);

🌰举例子：

std::list<int> list_assign_first;
std::list<int> list_assign_second;

list_assign_first.assign (7,100);                      // 7 ints with value 100
list_assign_second.assign (list_assign_first.begin(),list_assign_first.end()); // a copy of list_assign_first

int my_assign_ints[]={1776,7,4};
list_assign_first.assign (my_assign_ints,my_assign_ints+3);            // assigning from array

std::cout << "Size of list_assign_first: " << int (list_assign_first.size()) << '\n';
std::cout << "Size of list_assign_second: " << int (list_assign_second.size()) << '\n';

🎯运行结果：

---

🎄三、std::list对象的 清空、 删除

本小节介绍从 对象删除一个元素、清空整个std::list对象等操作。

✨3.1 清空链表

claer 函数可以清空链表，执行这个函数后，调用empty()会返回true

// 从列表容器中删除所有元素（这些元素已被销毁），并将容器的size保留为0。
void clear() noexcept;

🌰举例子：

// clear
std::list<int> list_clear;
std::list<int>::iterator it_clear;

list_clear.push_back (100);
list_clear.push_back (200);
list_clear.push_back (300);

std::cout << "list_clear contains:";
for (it_clear=list_clear.begin(); it_clear!=list_clear.end(); ++it_clear)
std::cout << ' ' << *it_clear;
std::cout << '\n';

list_clear.clear();
list_clear.push_back (1101);
list_clear.push_back (2202);

std::cout << "list_clear contains:";
for (it_clear=list_clear.begin(); it_clear!=list_clear.end(); ++it_clear)
std::cout << ' ' << *it_clear;
std::cout << '\n';

🎯运行结果：

---

✨3.2 从list对象 开头、结尾 删除字符

// 删除列表容器中的第一个元素，有效地将其大小减小1。
void pop_front();

// 删除列表容器中的最后一个元素，有效地将容器大小减少1。
void pop_back();

🌰举例子：

// 3.2 pop_front pop_back
std::list<int> list_pop;
list_pop.push_back (100);
list_pop.push_back (200);
list_pop.push_back (300);
list_pop.pop_front();
list_pop.pop_back();

---

✨3.3 删除指定位置的元素

erase函数：从列表容器中移除单个元素（position）或一段元素（[first,last）)。

相关函数原型如下：

iterator erase (const_iterator position);
iterator erase (const_iterator first, const_iterator last);

🌰举例子：

std::list<int> list_erese;
std::list<int>::iterator it1_erese,it2_erese;

// set some values:
for (int i=1; i<10; ++i) list_erese.push_back(i*10);
											// 10 20 30 40 50 60 70 80 90
it1_erese = it2_erese = list_erese.begin(); // ^^
advance (it2_erese,6);            			// ^                 ^
++it1_erese;                      			//    ^              ^
it1_erese = list_erese.erase (it1_erese);   // 10 30 40 50 60 70 80 90
											//    ^           ^
it2_erese = list_erese.erase (it2_erese);   // 10 30 40 50 60 80 90
											//    ^           ^
++it1_erese;                      			//       ^        ^
--it2_erese;                      			//       ^     ^
list_erese.erase (it1_erese,it2_erese);     // 10 30 60 80 90
											//        ^
std::cout << "list_erese contains:";
for (it1_erese=list_erese.begin(); it1_erese!=list_erese.end(); ++it1_erese)
std::cout << ' ' << *it1_erese;
std::cout << '\n';

🎯运行结果：

✨3.4 删除指定元素

remove：从容器中移除与val比较结果相等的所有元素。调用这些对象的析构函数，并按移除的元素数量减少容器大小。

remove_if ：从容器中移除Predicate pred返回true的所有元素。这将调用这些对象的析构函数，并根据删除的元素数量减少容器大小。

相关函数原型如下：

void remove (const value_type& val);

template <class Predicate>  void remove_if (Predicate pred);

🌰举例子：
首先写一个用在 remove_if 的函数：

// a predicate implemented as a function:
bool single_digit (const int& value) { return (value<10); }

接下来，看remove 、remove_if 例子：

// 3.4 remove、remove_if 
int ints_remove[]= {17,89,7,89,14};
std::list<int> list_remove (ints_remove,ints_remove+4);
list_remove.remove(89);
std::cout << "list_remove contains:";
for (std::list<int>::iterator it=list_remove.begin(); it!=list_remove.end(); ++it)
	std::cout << ' ' << *it;
std::cout << '\n';
 
int ints_remove_if[]= {15,36,7,17,20,39,4,1};
std::list<int> list_remove_if (ints_remove_if,ints_remove_if+8);   // 15 36 7 17 20 39 4 1
list_remove_if.remove_if (single_digit);           // 15 36 17 20 39
std::cout << "list_remove_if contains:";
for (std::list<int>::iterator it=list_remove_if.begin(); it!=list_remove_if.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';

🎯运行结果：

---

🎄四、修改 list

✨4.1 修改 std::list 对象大小

resize ：调整容器的大小，使其包含n个元素。
如果n小于当前容器的大小，则内容将被减少到前n个元素，并删除超出的元素（并销毁它们）。
如果n大于当前容器的大小，则通过在末尾插入所需的元素来扩展内容，以达到n的大小。如果指定了val，则将新元素初始化为val的副本，否则将其进行值初始化。

void resize (size_type n);
void resize (size_type n, const value_type& val);

🌰举例子：

// 4.1 resize
std::list<int> list_resize;
// set some initial content:
for (int i=1; i<10; ++i) list_resize.push_back(i);
list_resize.resize(5);
list_resize.resize(8,100);
list_resize.resize(12);
std::cout << "list_resize contains:";
for (std::list<int>::iterator it=list_resize.begin(); it!=list_resize.end(); ++it)
	std::cout << ' ' << *it;
std::cout << '\n';

🎯运行结果：

---

✨4.2 反转链表中所有元素的顺序

reverse：反转列表容器中元素的顺序。

void reverse() noexcept;

void sort();
template <class Compare>  void sort (Compare comp);

🌰举例子：

std::list<int> list_reverse;
for (int i=1; i<10; ++i) list_reverse.push_back(i);
list_reverse.reverse();
std::cout << "list_reverse contains:";
for (std::list<int>::iterator it=list_reverse.begin(); it!=list_reverse.end(); ++it)
	std::cout << ' ' << *it;
std::cout << '\n';

🎯运行结果：

---

✨4.3 链表交换

用 x链表 的内容交换容器的内容，x是另一个相同类型的列表。大小可能不同。

在调用this成员函数之后，this容器中的元素是调用之前在x中的元素，而x的元素是在this容器中的元素。所有迭代器、引用和指针对于交换后的对象仍然有效。

void swap (list& x);

🌰举例子：

std::list<int> list_swap_first (3,100);   // three ints with a value of 100
std::list<int> list_swap_second (5,200);  // five ints with a value of 200

list_swap_first.swap(list_swap_second);

std::cout << "list_swap_first contains:";
for (std::list<int>::iterator it=list_swap_first.begin(); it!=list_swap_first.end(); it++)
	std::cout << ' ' << *it;
std::cout << '\n';

std::cout << "list_swap_second contains:";
for (std::list<int>::iterator it=list_swap_second.begin(); it!=list_swap_second.end(); it++)
	std::cout << ' ' << *it;
std::cout << '\n';

🎯运行结果：

---

✨4.4 其他修改list相关的函数

splice ：将元素从 x列表 转移到容器中，并将它们插入position指定的位置，转移后 x列表 为空。

void splice (const_iterator position, list& x);
void splice (const_iterator position, list&& x);
void splice (const_iterator position, list& x, const_iterator i);
void splice (const_iterator position, list&& x, const_iterator i);
void splice (const_iterator position, list& x, const_iterator first, const_iterator last);
void splice (const_iterator position, list&& x, const_iterator first, const_iterator last);

---

🎄五、从链表 查询

✨5.1 查询链表元素个数

// 返回列表容器中元素的个数。
size_type size() const noexcept;

// 返回列表容器可容纳的最大元素数。
// 由于已知的系统或库实现限制，这是容器可以达到的最大潜在大小，但是容器不能保证能够达到这个大小：在达到这个大小之前，它仍然可能无法分配存储。
size_type max_size() const noexcept;

🌰举例子：

std::list<int> list_size;
std::cout <<"0. size: " << list_size.size() << '\n';

for (int i=0; i<10; i++) list_size.push_back(i);
std::cout << "1. size: " << list_size.size() << '\n';

list_size.insert (list_size.begin(),10,100);
std::cout << "2. size: " << list_size.size() << '\n';

list_size.pop_back();
std::cout << "3. size: " << list_size.size() << '\n';
std::cout << "maxsize: " << list_size.max_size() << '\n';

🎯运行结果：

---

✨5.2 查询第一个、最后一个元素

// 返回对列表容器中第一个元素的引用。
reference front();
const_reference front() const;

// 返回对列表容器中最后一个元素的引用。
reference back();
const_reference back() const;

🌰举例子：

std::list<int> list_front;
list_front.push_back(77);
list_front.push_back(22);// now front equals 77, and back 22

list_front.front() -= list_front.back();
std::cout << "list_front.front() is now " << list_front.front() << '\n';

🎯运行结果：

---

✨5.3 查询链表是否为空

返回列表容器是否为空（即它的大小是否为0）。

该函数不以任何方式修改容器。要清除列表容器的内容，请参见list::clear。

bool empty() const noexcept;

---

---

🎄六、其他

写太多了，其他的以后用到再补充吧！！！

本文详细介绍了C++标准库的 std::list，以及代码例子。

如果文章有帮助的话，点赞👍、收藏⭐，支持一波，谢谢 😁😁😁

https://cplusplus.com/reference/list/list/