【C++ STL】std::list

第一章 std::list 容器函数列表与讲解

一、构造函数

默认构造

函数功能：创建一个空的双向链表。
函数入参：无。
函数返回值：无（构造对象）。

使用举例 ：

cpp 复制代码

std::list<int> lst;
std::cout << "[默认构造] list size: " << lst.size() << ", empty: " << lst.empty() << std::endl;

填充构造

函数功能：创建包含指定数量相同元素的链表。
函数入参 ：count (元素数量), value (默认值)。
函数返回值：无（构造对象）。

使用举例 ：

cpp 复制代码

std::list<int> lst(5, 42);
std::cout << "[填充构造] list(5, 42): ";
for (const auto& val : lst) std::cout << val << " ";
std::cout << std::endl;

范围构造

函数功能 ：使用迭代器区间 [first, last) 内的元素进行构造。
函数入参 ：first (起始迭代器), last (结束迭代器)。
函数返回值：无（构造对象）。

使用举例 ：

cpp 复制代码

std::vector<int> vec = {10, 20, 30, 40, 50};
std::list<int> lst(vec.begin(), vec.end());
std::cout << "[范围构造] from vector: ";
for (const auto& val : lst) std::cout << val << " ";
std::cout << std::endl;

拷贝构造

函数功能：使用另一个 list 的内容进行深拷贝构造。
函数入参 ：other (另一个 list 对象)。
函数返回值：无（构造对象）。

使用举例 ：

cpp 复制代码

std::list<int> original = {1, 2, 3, 4, 5};
std::list<int> copied(original);
std::cout << "[拷贝构造] copied: ";
for (const auto& val : copied) std::cout << val << " ";
std::cout << std::endl;

移动构造

函数功能：转移另一个 list 的资源，原对象变为空。
函数入参 ：other (右值引用)。
函数返回值：无（构造对象）。

使用举例 ：

cpp 复制代码

std::list<std::string> source = {"hello", "world", "list"};
std::list<std::string> moved(std::move(source));
std::cout << "[移动构造] moved: ";
for (const auto& val : moved) std::cout << val << " ";
std::cout << std::endl;

初始化列表构造

函数功能 ：使用初始化列表 {...} 中的元素进行构造。
函数入参 ：init (initializer_list)。
函数返回值：无（构造对象）。

使用举例 ：

cpp 复制代码

std::list<int> lst = {100, 200, 300, 400, 500};
std::cout << "[初始化列表] lst: ";
for (const auto& val : lst) std::cout << val << " ";
std::cout << std::endl;

二、赋值操作

`operator=`

函数功能：替换容器内容（支持拷贝、移动、初始化列表）。
函数入参：另一个 list 对象、右值引用或初始化列表。
函数返回值 ：*this (当前对象的引用)。

使用举例 ：

cpp 复制代码

std::list<int> lst1 = {1, 2, 3};
std::list<int> lst2;
lst2 = lst1;
std::cout << "[拷贝赋值] lst2: ";
for (const auto& val : lst2) std::cout << val << " ";
std::cout << std::endl;

`assign` (填充)

函数功能：替换容器内容为指定数量的相同值。
函数入参 ：count (数量), value (值)。
函数返回值 ：void。

使用举例 ：

cpp 复制代码

std::list<int> lst;
lst.assign(6, 99);
std::cout << "[assign填充] lst: ";
for (const auto& val : lst) std::cout << val << " ";
std::cout << std::endl;

`assign` (范围)

函数功能 ：替换容器内容为迭代器区间 [first, last) 的元素。
函数入参 ：first, last (迭代器)。
函数返回值 ：void。

使用举例 ：

cpp 复制代码

std::list<int> lst;
int arr[] = {11, 22, 33, 44, 55};
lst.assign(arr, arr + 5);
std::cout << "[assign范围] lst: ";
for (const auto& val : lst) std::cout << val << " ";
std::cout << std::endl;

`assign` (列表)

函数功能：替换容器内容为初始化列表中的元素。
函数入参 ：init (initializer_list)。
函数返回值 ：void。

使用举例 ：

cpp 复制代码

std::list<std::string> lst;
lst.assign({"apple", "banana", "cherry"});
std::cout << "[assign初始化列表] lst: ";
for (const auto& val : lst) std::cout << val << " ";
std::cout << std::endl;

三、元素访问

`front`

函数功能：访问容器的第一个元素。
函数入参：无。
函数返回值：指向首元素的引用。

使用举例 ：

cpp 复制代码

std::list<std::string> lst = {"first", "second", "third"};
std::cout << "[front] " << lst.front() << std::endl;
lst.front() = "modified_first";

`back`

函数功能：访问容器的最后一个元素。
函数入参：无。
函数返回值：指向尾元素的引用。

使用举例 ：

cpp 复制代码

std::list<std::string> lst = {"first", "second", "third"};
std::cout << "[back] " << lst.back() << std::endl;
lst.back() = "modified_last";

四、迭代器

`begin` / `end`

函数功能：获取指向首/尾元素（尾后）的正向迭代器。
函数入参：无。
函数返回值 ：iterator。

使用举例 ：

cpp 复制代码

std::list<int> lst = {1, 2, 3, 4, 5};
for (auto it = lst.begin(); it != lst.end(); ++it) {
    std::cout << *it << " ";
}

`cbegin` / `cend`

函数功能：获取指向首/尾元素的常量正向迭代器（只读）。
函数入参：无。
函数返回值 ：const_iterator。

使用举例 ：

cpp 复制代码

for (auto it = lst.cbegin(); it != lst.cend(); ++it) {
    std::cout << *it << " ";
}

`rbegin` / `rend`

函数功能：获取指向尾/首元素（首前）的反向迭代器。
函数入参：无。
函数返回值 ：reverse_iterator。

使用举例 ：

cpp 复制代码

for (auto it = lst.rbegin(); it != lst.rend(); ++it) {
    std::cout << *it << " ";
}

`crbegin` / `crend`

函数功能：获取指向尾/首元素的常量反向迭代器（只读）。
函数入参：无。
函数返回值 ：const_reverse_iterator。

使用举例 ：

cpp 复制代码

for (auto it = lst.crbegin(); it != lst.crend(); ++it) {
    std::cout << *it << " ";
}

五、容量相关

`empty`

函数功能：检查容器是否为空。
函数入参：无。
函数返回值 ：bool (true 为空)。

使用举例 ：

cpp 复制代码

std::cout << "[empty] lst: " << (lst.empty() ? "空" : "非空") << std::endl;

`size`

函数功能：获取容器中的元素数量。
函数入参：无。
函数返回值 ：size_type (元素个数)。

使用举例 ：

cpp 复制代码

std::cout << "[size] lst.size() = " << lst.size() << std::endl;

`max_size`

函数功能：获取容器支持的最大元素数量。
函数入参：无。
函数返回值 ：size_type (最大容量)。

使用举例 ：

cpp 复制代码

std::cout << "[max_size] int list max_size = " << lst.max_size() << std::endl;

六、修改操作

`clear`

函数功能：清除所有元素。
函数入参：无。
函数返回值 ：void。

使用举例 ：

cpp 复制代码

lst.clear();
std::cout << "[clear] 清除后 size = " << lst.size() << std::endl;

`insert`

函数功能：在指定位置插入元素（支持单元素、填充、范围、列表）。
函数入参 ：pos (迭代器), 值/数量/范围/列表。
函数返回值：指向第一个插入元素的迭代器。

使用举例 ：

cpp 复制代码

auto it = lst.begin(); std::advance(it, 2);
lst.insert(it, 4);

`emplace`

函数功能：在指定位置原地构造元素。
函数入参 ：pos (迭代器), 构造参数。
函数返回值：指向新元素的迭代器。

使用举例 ：

cpp 复制代码

students.emplace(students.begin(), "Xander", 21, 95.0);

`erase`

函数功能：移除指定位置或区间的元素。
函数入参 ：pos 或 first, last (迭代器)。
函数返回值：指向被擦除元素后一个元素的迭代器。

使用举例 ：

cpp 复制代码

auto it = lst.begin(); std::advance(it, 2);
lst.erase(it);

`push_back` / `push_front`

函数功能：在容器末尾/开头添加元素。
函数入参 ：value (值)。
函数返回值 ：void。
使用举例 ：
cpp 复制代码
```
lst.push_back(10);
lst.push_front(0);
```

`emplace_back` / `emplace_front`

函数功能：在容器末尾/开头原地构造元素。
函数入参：构造参数。
函数返回值 ：void (C++17起返回引用)。

使用举例 ：

cpp 复制代码

students.emplace_back("Alice", 22, 95.5);
students.emplace_front("Bob", 21, 88.0);

`pop_back` / `pop_front`

函数功能：移除容器末尾/开头的元素。
函数入参：无。
函数返回值 ：void。
使用举例 ：
cpp 复制代码
```
lst.pop_back();
lst.pop_front();
```

`resize`

函数功能：改变容器中存储的元素数量。
函数入参 ：count (新大小), value (可选，填充值)。
函数返回值 ：void。
使用举例 ：
cpp 复制代码
```
lst.resize(8, 99);
```

七、list 特有操作

`splice`

函数功能：将元素从另一个 list 移入当前 list（不复制，仅移动节点指针）。
函数入参 ：pos (目标位置), other (源list), 可选的源位置或范围。
函数返回值 ：void。
使用举例 ：
cpp 复制代码
```
lst1.splice(lst1.end(), lst2);
```

`remove` / `remove_if`

函数功能：移除所有等于特定值或满足谓词条件的元素。
函数入参 ：value 或 pred (一元谓词)。
函数返回值 ：void (C++20前), size_type (C++20起)。

使用举例 ：

cpp 复制代码

lst.remove(2);
lst.remove_if([](int x){ return x % 2 == 0; });

`unique`

函数功能：移除连续重复的元素。
函数入参：可选的二元谓词。
函数返回值 ：void (C++20前), size_type (C++20起)。
使用举例 ：
cpp 复制代码
```
lst.unique();
```

`merge`

函数功能：合并两个已排序的 list（源 list 变为空）。
函数入参 ：other (另一个已排序的 list), 可选比较函数。
函数返回值 ：void。
使用举例 ：
cpp 复制代码
```
lst1.merge(lst2);
```

`sort`

函数功能：对链表元素进行排序（list 专用成员函数）。
函数入参：可选比较函数。
函数返回值 ：void。

使用举例 ：

cpp 复制代码

lst.sort();
lst.sort(std::greater<int>());

`reverse`

函数功能：反转链表中元素的顺序。
函数入参：无。
函数返回值 ：void。
使用举例 ：
cpp 复制代码
```
lst.reverse();
```

八、swap 与非成员函数

`swap`

函数功能：交换两个容器的内容。
函数入参 ：other (另一个 list)。
函数返回值 ：void。
使用举例 ：
cpp 复制代码
```
lst1.swap(lst2);
```

比较运算符

函数功能 ：按字典序比较两个 list (==, !=, <, >, <=, >=)。
函数入参 ：lhs, rhs。
函数返回值 ：bool。

使用举例 ：

cpp 复制代码

std::cout << "[==] lst1 == lst2: " << (lst1 == lst2) << std::endl;

第二章分模块代码解析

一、构造函数相关

展示了 list 的 6 种构造方式：默认、填充、范围、拷贝、移动和初始化列表。

cpp 复制代码

void demo_default_constructor() {
    std::list<int> lst;
    std::cout << "[默认构造] list size: " << lst.size() << ", empty: " << lst.empty() << std::endl;
}

void demo_fill_constructor() {
    std::list<int> lst(5, 42);
    std::cout << "[填充构造] list(5, 42): ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_range_constructor() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    std::list<int> lst(vec.begin(), vec.end());
    std::cout << "[范围构造] from vector: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_copy_constructor() {
    std::list<int> original = {1, 2, 3, 4, 5};
    std::list<int> copied(original);
    std::cout << "[拷贝构造] copied: ";
    for (const auto& val : copied) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_move_constructor() {
    std::list<std::string> source = {"hello", "world", "list"};
    std::list<std::string> moved(std::move(source));
    std::cout << "[移动构造] moved: ";
    for (const auto& val : moved) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_initializer_list_constructor() {
    std::list<int> lst = {100, 200, 300, 400, 500};
    std::cout << "[初始化列表] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

二、赋值操作

演示了使用 = 和 assign 进行内容替换的各种方式。

cpp 复制代码

void demo_copy_assignment() {
    std::list<int> lst1 = {1, 2, 3};
    std::list<int> lst2;
    lst2 = lst1;
    std::cout << "[拷贝赋值] lst2: ";
    for (const auto& val : lst2) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_move_assignment() {
    std::list<int> lst1 = {10, 20, 30};
    std::list<int> lst2;
    lst2 = std::move(lst1);
    std::cout << "[移动赋值] lst2: ";
    for (const auto& val : lst2) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_initializer_list_assignment() {
    std::list<int> lst;
    lst = {7, 8, 9, 10};
    std::cout << "[初始化列表赋值] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_assign_fill() {
    std::list<int> lst;
    lst.assign(6, 99);
    std::cout << "[assign填充] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_assign_range() {
    std::list<int> lst;
    int arr[] = {11, 22, 33, 44, 55};
    lst.assign(arr, arr + 5);
    std::cout << "[assign范围] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_assign_initializer_list() {
    std::list<std::string> lst;
    lst.assign({"apple", "banana", "cherry"});
    std::cout << "[assign初始化列表] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

三、元素访问

包含首尾元素访问及修改演示。注意 list 不支持下标随机访问。

cpp 复制代码

void demo_front() {
    std::list<std::string> lst = {"first", "second", "third"};
    std::cout << "[front] " << lst.front() << std::endl;
    lst.front() = "modified_first";
    std::cout << "[front] 修改后: " << lst.front() << std::endl;
}

void demo_back() {
    std::list<std::string> lst = {"first", "second", "third"};
    std::cout << "[back] " << lst.back() << std::endl;
    lst.back() = "modified_last";
    std::cout << "[back] 修改后: " << lst.back() << std::endl;
}

四、迭代器

展示正向/反向、常量/非常量四种迭代器的遍历与修改操作。

cpp 复制代码

void demo_begin_end() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    std::cout << "[begin/end] 正向遍历: ";
    for (auto it = lst.begin(); it != lst.end(); ++it) std::cout << *it << " ";
    std::cout << std::endl;
    for (auto it = lst.begin(); it != lst.end(); ++it) *it *= 10;
    std::cout << "[begin/end] 修改后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_cbegin_cend() {
    std::list<int> lst = {10, 20, 30, 40, 50};
    std::cout << "[cbegin/cend] const遍历: ";
    for (auto it = lst.cbegin(); it != lst.cend(); ++it) std::cout << *it << " ";
    std::cout << std::endl;
}

void demo_rbegin_rend() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    std::cout << "[rbegin/rend] 反向遍历: ";
    for (auto it = lst.rbegin(); it != lst.rend(); ++it) std::cout << *it << " ";
    std::cout << std::endl;
}

void demo_crbegin_crend() {
    std::list<int> lst{10, 20, 30, 40, 50};
    std::cout << "[crbegin/crend] const反向遍历: ";
    for (auto it = lst.crbegin(); it != lst.crend(); ++it) std::cout << *it << " ";
    std::cout << std::endl;
}

五、容量相关

涉及容器状态查询，包括判空、大小和最大容量限制。

cpp 复制代码

void demo_empty() {
    std::list<int> lst1;
    std::list<int> lst2 = {1, 2, 3};
    std::cout << "[empty] lst1: " << (lst1.empty() ? "空" : "非空") << std::endl;
    std::cout << "[empty] lst2: " << (lst2.empty() ? "空" : "非空") << std::endl;
}

void demo_size() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    std::cout << "[size] lst.size() = " << lst.size() << std::endl;
    lst.push_back(6);
    std::cout << "[size] push_back后 lst.size() = " << lst.size() << std::endl;
}

void demo_max_size() {
    std::list<int> lst;
    std::cout << "[max_size] int list max_size = " << lst.max_size() << std::endl;
}

六、修改操作

涵盖元素的增删改查基础操作，包括 insert、erase、push/pop、emplace 和 resize。

cpp 复制代码

void demo_clear() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.clear();
    std::cout << "[clear] 清除后 size = " << lst.size() << ", empty = " << lst.empty() << std::endl;
}

void demo_insert_single() {
    std::list<int> lst = {1, 2, 3};
    auto it = lst.begin(); std::advance(it, 2);
    auto ret = lst.insert(it, 4);
    std::cout << "[insert单元素] 插入后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << ", 返回指向: " << *ret << std::endl;
}

void demo_emplace() {
    std::list<Student> students;
    students.emplace_back("Zara", 20, 91.0);
    auto it = students.begin();
    auto ret = students.emplace(it, "Xander", 21, 95.0);
    std::cout << "[emplace] 返回指向: " << *ret << std::endl;
}

void demo_erase_single() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    auto it = lst.begin(); std::advance(it, 2);
    auto ret = lst.erase(it);
    std::cout << "[erase单元素] 删除后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_push_back() {
    std::list<int> lst;
    for (int i = 1; i <= 5; i++) lst.push_back(i * 10);
    std::cout << "[push_back] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_push_front() {
    std::list<int> lst = {3, 4, 5};
    lst.push_front(2); lst.push_front(1);
    std::cout << "[push_front] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_pop_back() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.pop_back();
    std::cout << "[pop_back] 弹出后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_pop_front() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.pop_front();
    std::cout << "[pop_front] 弹出后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_resize() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.resize(8, 99);
    std::cout << "[resize] 扩大到8: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

七、list 特有操作

展示 list 独有的高效操作：splice、remove、unique、merge、sort、reverse。这些操作利用链表节点指针重连实现 O(1) 或 O(n) 复杂度，无需元素拷贝。

cpp 复制代码

void demo_splice() {
    std::list<int> lst1 = {1, 2, 3};
    std::list<int> lst2 = {4, 5, 6};
    lst1.splice(lst1.end(), lst2);
    std::cout << "[splice] lst1: ";
    for (const auto& val : lst1) std::cout << val << " ";
    std::cout << " | lst2 size: " << lst2.size() << std::endl;
}

void demo_remove() {
    std::list<int> lst = {1, 2, 3, 2, 4, 2, 5};
    lst.remove(2);
    std::cout << "[remove] 移除2后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_remove_if() {
    std::list<int> lst = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    lst.remove_if([](int x) { return x % 2 == 0; });
    std::cout << "[remove_if] 移除偶数后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_unique() {
    std::list<int> lst = {1, 1, 2, 2, 3, 3, 3, 4};
    lst.unique();
    std::cout << "[unique] 去重后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_merge() {
    std::list<int> lst1 = {1, 3, 5, 7};
    std::list<int> lst2 = {2, 4, 6, 8};
    lst1.merge(lst2);
    std::cout << "[merge] 合并后: ";
    for (const auto& val : lst1) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_sort() {
    std::list<int> lst = {5, 3, 1, 4, 2};
    lst.sort();
    std::cout << "[sort升序] ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
    lst.sort(std::greater<int>());
    std::cout << "[sort降序] ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_reverse() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.reverse();
    std::cout << "[reverse] ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

八、swap 与非成员函数

包含容器交换和字典序比较运算符的使用。

cpp 复制代码

void demo_swap() {
    std::list<int> lst1 = {1, 2, 3};
    std::list<int> lst2 = {10, 20, 30, 40};
    lst1.swap(lst2);
    std::cout << "[swap] 交换后 lst1: ";
    for (const auto& val : lst1) std::cout << val << " ";
    std::cout << " | lst2: ";
    for (const auto& val : lst2) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_comparison_operators() {
    std::list<int> lst1 = {1, 2, 3};
    std::list<int> lst2 = {1, 2, 3};
    std::list<int> lst3 = {1, 2, 4};
    std::cout << "[==] lst1 == lst2: " << (lst1 == lst2) << std::endl;
    std::cout << "[<] lst1 < lst3: " << (lst1 < lst3) << std::endl;
}

九、遍历方式

展示范围 for、迭代器正向遍历和反向迭代器遍历三种方式。list 不支持下标遍历。

cpp 复制代码

void demo_range_for() {
    std::list<int> lst = {10, 20, 30, 40, 50};
    std::cout << "[范围for] ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

void demo_iterator_traversal() {
    std::list<Student> students = {
        Student("Alice", 22, 95.5),
        Student("Bob", 21, 88.0)
    };
    std::cout << "[迭代器遍历] " << std::endl;
    for (auto it = students.begin(); it != students.end(); ++it)
        std::cout << "  " << *it << std::endl;
}

void demo_reverse_traversal() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    std::cout << "[反向遍历] ";
    for (auto it = lst.rbegin(); it != lst.rend(); ++it)
        std::cout << *it << " ";
    std::cout << std::endl;
}

十、与算法配合

展示 list 与 STL 通用算法的配合使用，包括 find、count、accumulate 和 for_each。

cpp 复制代码

void demo_find() {
    std::list<int> lst = {10, 20, 30, 40, 50};
    auto it = std::find(lst.begin(), lst.end(), 30);
    if (it != lst.end()) std::cout << "[find] 找到30" << std::endl;
    auto it2 = std::find_if(lst.begin(), lst.end(), [](int x) { return x > 25; });
    if (it2 != lst.end()) std::cout << "[find_if] 第一个>25: " << *it2 << std::endl;
}

void demo_count() {
    std::list<int> lst = {1, 2, 2, 3, 2, 4, 2, 5};
    auto cnt = std::count(lst.begin(), lst.end(), 2);
    std::cout << "[count] 2出现次数: " << cnt << std::endl;
}

void demo_accumulate() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    int sum = std::accumulate(lst.begin(), lst.end(), 0);
    std::cout << "[accumulate] 求和: " << sum << std::endl;
}

void demo_for_each() {
    std::list<Student> students = {Student("Alice", 22, 95.5)};
    std::for_each(students.begin(), students.end(),
        [](const Student& s) { std::cout << "  " << s.getName() << std::endl; });
}

第三章完整代码

cpp 复制代码

#include<iostream>
#include<list>
#include<vector>
#include<algorithm>
#include<numeric>
#include<string>
#include<cassert>
#include<functional>
#include<initializer_list>
#include<unordered_map>

/*
 * 自定义类型定义
 */

class Student
{
public:
    Student() = default;

    Student(std::string name, int age, double score)
        : name_(std::move(name)), age_(age), score_(score)
    {
    }

    Student(const Student& other)
        : name_(other.name_), age_(other.age_), score_(other.score_)
    {
    }

    Student(Student&& other) noexcept
        : name_(std::move(other.name_)), age_(other.age_), score_(other.score_)
    {
    }

    Student& operator=(Student other)
    {
        std::swap(name_, other.name_);
        std::swap(age_, other.age_);
        std::swap(score_, other.score_);
        return *this;
    }

    bool operator==(const Student& other) const
    {
        return name_ == other.name_ && age_ == other.age_ && score_ == other.score_;
    }

    bool operator!=(const Student& other) const { return !(*this == other); }

    bool operator<(const Student& other) const
    {
        return std::tie(score_, age_, name_) <
            std::tie(other.score_, other.age_, other.name_);
    }

    bool operator>(const Student& other) const { return other < *this; }
    bool operator<=(const Student& other) const { return !(other < *this); }
    bool operator>=(const Student& other) const { return !(*this < other); }

    friend std::ostream& operator<<(std::ostream& os, const Student& s)
    {
        os << "Student{name=\"" << s.name_ << "\", age=" << s.age_
            << ", score=" << s.score_ << "}";
        return os;
    }

    const std::string& getName() const { return name_; }
    int getAge() const { return age_; }
    double getScore() const { return score_; }

    void setName(const std::string& name) { name_ = name; }
    void setAge(int age) { age_ = age; }
    void setScore(double score) { score_ = score; }

private:
    std::string name_;
    int age_ = 0;
    double score_ = 0.0;
};

class Task
{
public:
    Task() = default;
    Task(int id, std::string desc, int priority)
        : id_(id), description_(std::move(desc)), priority_(priority) { }
    Task(const Task&) = default;
    Task(Task&&) noexcept = default;

    Task& operator=(const Task&) = default;
    Task& operator=(Task&&) noexcept = default;

    bool operator==(const Task& other) const { return id_ == other.id_; }
    bool operator<(const Task& other) const { return priority_ < other.priority_; }

    friend std::ostream& operator<<(std::ostream& os, const Task& t)
    {
        os << "Task{id=" << t.id_ << ", desc=\"" << t.description_
            << "\", priority=" << t.priority_ << "}";
        return os;
    }

    int getId() const { return id_; }
    const std::string& getDescription() const { return description_; }
    int getPriority() const { return priority_; }

private:
    int id_ = 0;
    std::string description_;
    int priority_ = 0;
};

// ====================================================================

/*
 * 1. 构造函数相关
 */

// 1.1 默认构造
void demo_default_constructor()
{
    std::list<int> lst;
    std::cout << "[默认构造] list size: " << lst.size() << ", empty: " << lst.empty() << std::endl;
}

// 1.2 填充构造
void demo_fill_constructor()
{
    std::list<int> lst(5, 42);
    std::cout << "[填充构造] list(5, 42): ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;

    std::list<Student> students(3, Student("Default", 20, 90.0));
    std::cout << "[填充构造-自定义类型] size: " << students.size() << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
}

// 1.3 范围构造
void demo_range_constructor()
{
    std::vector<int> vec = { 10, 20, 30, 40, 50 };
    std::list<int> lst(vec.begin(), vec.end());
    std::cout << "[范围构造] from vector: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 1.4 拷贝构造
void demo_copy_constructor()
{
    std::list<int> original = { 1, 2, 3, 4, 5 };
    std::list<int> copied(original);
    std::cout << "[拷贝构造] copied: ";
    for (const auto& val : copied) std::cout << val << " ";
    std::cout << std::endl;
}

// 1.5 移动构造
void demo_move_constructor()
{
    std::list<std::string> source = { "hello", "world", "list" };
    std::list<std::string> moved(std::move(source));
    std::cout << "[移动构造] moved: ";
    for (const auto& val : moved) std::cout << val << " ";
    std::cout << std::endl;
    std::cout << "[移动构造] source size after move: " << source.size() << std::endl;
}

// 1.6 初始化列表构造
void demo_initializer_list_constructor()
{
    std::list<int> lst = { 100, 200, 300, 400, 500 };
    std::cout << "[初始化列表] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;

    std::list<Student> students = {
        Student("Alice", 22, 95.5),
        Student("Bob", 21, 88.0),
        Student("Charlie", 23, 92.3)
    };
    std::cout << "[初始化列表-自定义类型] size: " << students.size() << std::endl;
}

// ====================================================================

/*
 * 2. 赋值操作
 */

// 2.1 拷贝赋值
void demo_copy_assignment()
{
    std::list<int> lst1 = { 1, 2, 3 };
    std::list<int> lst2;
    lst2 = lst1;
    std::cout << "[拷贝赋值] lst2: ";
    for (const auto& val : lst2) std::cout << val << " ";
    std::cout << std::endl;
}

// 2.2 移动赋值
void demo_move_assignment()
{
    std::list<int> lst1 = { 10, 20, 30 };
    std::list<int> lst2;
    lst2 = std::move(lst1);
    std::cout << "[移动赋值] lst2: ";
    for (const auto& val : lst2) std::cout << val << " ";
    std::cout << std::endl;
    std::cout << "[移动赋值] lst1 size after move: " << lst1.size() << std::endl;
}

// 2.3 初始化列表赋值
void demo_initializer_list_assignment()
{
    std::list<int> lst;
    lst = { 7, 8, 9, 10 };
    std::cout << "[初始化列表赋值] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 2.4 填充赋值
void demo_assign_fill()
{
    std::list<int> lst;
    lst.assign(6, 99);
    std::cout << "[assign填充] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 2.5 范围赋值
void demo_assign_range()
{
    std::list<int> lst;
    int arr[] = { 11, 22, 33, 44, 55 };
    lst.assign(arr, arr + 5);
    std::cout << "[assign范围] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 2.6 初始化列表赋值
void demo_assign_initializer_list()
{
    std::list<std::string> lst;
    lst.assign({ "apple", "banana", "cherry" });
    std::cout << "[assign初始化列表] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// ====================================================================

/*
 * 3. 元素访问
 */

// 3.1 front
void demo_front()
{
    std::list<std::string> lst = { "first", "second", "third" };
    std::cout << "[front] " << lst.front() << std::endl;
    lst.front() = "modified_first";
    std::cout << "[front] 修改后: " << lst.front() << std::endl;
}

// 3.2 back
void demo_back()
{
    std::list<std::string> lst = { "first", "second", "third" };
    std::cout << "[back] " << lst.back() << std::endl;
    lst.back() = "modified_last";
    std::cout << "[back] 修改后: " << lst.back() << std::endl;
}

// ====================================================================

/*
 * 4. 迭代器
 */

// 4.1 正向迭代 begin / end
void demo_begin_end()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    std::cout << "[begin/end] 正向遍历: ";
    for (auto it = lst.begin(); it != lst.end(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    for (auto it = lst.begin(); it != lst.end(); ++it)
    {
        *it *= 10;
    }
    std::cout << "[begin/end] 修改后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 4.2 const正向迭代 cbegin / cend
void demo_cbegin_cend()
{
    std::list<int> lst = { 10, 20, 30, 40, 50 };
    std::cout << "[cbegin/cend] const遍历: ";
    for (auto it = lst.cbegin(); it != lst.cend(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// 4.3 反向迭代 rbegin / rend
void demo_rbegin_rend()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    std::cout << "[rbegin/rend] 反向遍历: ";
    for (auto it = lst.rbegin(); it != lst.rend(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// 4.4 const反向迭代 crbegin / crend
void demo_crbegin_crend()
{
    std::list<int> lst{ 10, 20, 30, 40, 50 };
    std::cout << "[crbegin/crend] const反向遍历: ";
    for (auto it = lst.crbegin(); it != lst.crend(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// ====================================================================

/*
 * 5. 容量相关
 */

// 5.1 empty
void demo_empty()
{
    std::list<int> lst1;
    std::list<int> lst2 = { 1, 2, 3 };
    std::cout << "[empty] lst1: " << (lst1.empty() ? "空" : "非空") << std::endl;
    std::cout << "[empty] lst2: " << (lst2.empty() ? "空" : "非空") << std::endl;
}

// 5.2 size
void demo_size()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    std::cout << "[size] lst.size() = " << lst.size() << std::endl;
    lst.push_back(6);
    std::cout << "[size] push_back后 lst.size() = " << lst.size() << std::endl;
}

// 5.3 max_size
void demo_max_size()
{
    std::list<int> lst;
    std::cout << "[max_size] int list max_size = " << lst.max_size() << std::endl;

    std::list<Student> students;
    std::cout << "[max_size] Student list max_size = " << students.max_size() << std::endl;
}

// ====================================================================

/*
 * 6. 修改操作
 */

// 6.1 clear
void demo_clear()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    std::cout << "[clear] 清除前 size = " << lst.size() << std::endl;
    lst.clear();
    std::cout << "[clear] 清除后 size = " << lst.size()
        << ", empty = " << lst.empty() << std::endl;
}

// 6.2 insert单元素
void demo_insert_single()
{
    std::list<int> lst = { 1, 2, 3 };
    auto it = lst.begin();
    std::advance(it, 2);
    auto ret = lst.insert(it, 4);
    std::cout << "[insert单元素] 插入后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
    std::cout << "[insert单元素] 返回迭代器指向: " << *ret << std::endl;
}

// 6.3 insert填充
void demo_insert_fill()
{
    std::list<int> lst = { 1, 2, 3 };
    lst.insert(lst.end(), 3, 88);
    std::cout << "[insert填充] 插入后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.4 insert范围
void demo_insert_range()
{
    std::list<int> lst = { 1, 2, 7, 8 };
    std::vector<int> extra = { 3, 4, 5, 6 };
    auto it = lst.begin();
    std::advance(it, 2);
    lst.insert(it, extra.begin(), extra.end());
    std::cout << "[insert范围] 插入后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.5 insert初始化列表
void demo_insert_initializer_list()
{
    std::list<std::string> lst = { "a", "e" };
    auto it = lst.begin();
    ++it;
    lst.insert(it, { "b", "c", "d" });
    std::cout << "[insert初始化列表] 插入后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.6 emplace
void demo_emplace()
{
    std::list<Student> students;
    students.emplace_back("Zara", 20, 91.0);
    students.emplace_back("Yuki", 22, 88.5);

    auto it = students.begin();
    ++it;
    auto ret = students.emplace(it, "Xander", 21, 95.0);
    std::cout << "[emplace] 插入后: " << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
    std::cout << "[emplace] 返回迭代器指向: " << *ret << std::endl;
}

// 6.7 erase单元素
void demo_erase_single()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    auto it = lst.begin();
    std::advance(it, 2);
    auto ret = lst.erase(it);
    std::cout << "[erase单元素] 删除后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
    if (ret != lst.end())
        std::cout << "[erase单元素] 返回迭代器指向: " << *ret << std::endl;
}

// 6.8 erase范围
void demo_erase_range()
{
    std::list<int> lst = { 1, 2, 3, 4, 5, 6, 7, 8 };
    auto first = lst.begin();
    std::advance(first, 2);
    auto last = lst.begin();
    std::advance(last, 5);
    auto ret = lst.erase(first, last);
    std::cout << "[erase范围] 删除后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
    if (ret != lst.end())
        std::cout << "[erase范围] 返回迭代器指向: " << *ret << std::endl;
}

// 6.9 push_back
void demo_push_back()
{
    std::list<int> lst;
    for (int i = 1; i <= 5; i++) lst.push_back(i * 10);
    std::cout << "[push_back] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;

    std::list<Student> students;
    students.push_back(Student("Tom", 20, 85.0));
    students.push_back(Student("Jerry", 21, 90.0));
    std::cout << "[push_back-Student] size = " << students.size() << std::endl;
}

// 6.10 push_front
void demo_push_front()
{
    std::list<int> lst = { 3, 4, 5 };
    lst.push_front(2);
    lst.push_front(1);
    std::cout << "[push_front] lst: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.11 emplace_back
void demo_emplace_back()
{
    std::list<Student> students;
    students.emplace_back("Alice", 22, 95.5);
    students.emplace_back("Bob", 21, 88.0);
    students.emplace_back("Charlie", 23, 92.3);
    std::cout << "[emplace_back] students: " << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
}

// 6.12 emplace_front
void demo_emplace_front()
{
    std::list<Student> students;
    students.emplace_back("Bob", 21, 88.0);
    students.emplace_front("Alice", 22, 95.0);
    std::cout << "[emplace_front] students: " << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
}

// 6.13 pop_back
void demo_pop_back()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    std::cout << "[pop_back] 弹出前: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
    lst.pop_back();
    std::cout << "[pop_back] 弹出后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.14 pop_front
void demo_pop_front()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    std::cout << "[pop_front] 弹出前: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
    lst.pop_front();
    std::cout << "[pop_front] 弹出后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.15 resize
void demo_resize()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    lst.resize(8, 99);
    std::cout << "[resize] 扩大到8（默认99）: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;

    lst.resize(3);
    std::cout << "[resize] 缩小到3: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// ====================================================================

/*
 * 7. list 特有操作
 */

// 7.1 splice
void demo_splice()
{
    std::list<int> lst1 = { 1, 2, 3 };
    std::list<int> lst2 = { 4, 5, 6 };
    lst1.splice(lst1.end(), lst2);
    std::cout << "[splice-全部] lst1: ";
    for (const auto& val : lst1) std::cout << val << " ";
    std::cout << " | lst2 size: " << lst2.size() << std::endl;

    std::list<int> lst3 = { 10, 20, 30, 40, 50 };
    auto it = lst3.begin();
    std::advance(it, 2);
    lst1.splice(lst1.begin(), lst3, it);
    std::cout << "[splice-单元素] lst1: ";
    for (const auto& val : lst1) std::cout << val << " ";
    std::cout << std::endl;
}

// 7.2 remove
void demo_remove()
{
    std::list<int> lst = { 1, 2, 3, 2, 4, 2, 5 };
    lst.remove(2);
    std::cout << "[remove] 移除2后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 7.3 remove_if
void demo_remove_if()
{
    std::list<int> lst = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    lst.remove_if([](int x) { return x % 2 == 0; });
    std::cout << "[remove_if] 移除偶数后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 7.4 unique
void demo_unique()
{
    std::list<int> lst = { 1, 1, 2, 2, 3, 3, 3, 4 };
    lst.unique();
    std::cout << "[unique] 去重后: ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// 7.5 merge
void demo_merge()
{
    std::list<int> lst1 = { 1, 3, 5, 7 };
    std::list<int> lst2 = { 2, 4, 6, 8 };
    lst1.merge(lst2);
    std::cout << "[merge] 合并后 lst1: ";
    for (const auto& val : lst1) std::cout << val << " ";
    std::cout << " | lst2 size: " << lst2.size() << std::endl;
}

// 7.6 sort
void demo_sort()
{
    std::list<int> lst = { 5, 3, 1, 4, 2 };
    lst.sort();
    std::cout << "[sort升序] ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;

    lst.sort(std::greater<int>());
    std::cout << "[sort降序] ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;

    std::list<Student> students = {
        Student("Alice", 22, 82.0),
        Student("Bob", 21, 95.0),
        Student("Charlie", 23, 90.0)
    };
    students.sort([](const Student& a, const Student& b) {
        return a.getScore() > b.getScore();
        });
    std::cout << "[sort-按分数排序] " << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
}

// 7.7 reverse
void demo_reverse()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    lst.reverse();
    std::cout << "[reverse] ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;
}

// ====================================================================

/*
 * 8. swap 与非成员函数
 */

// 8.1 swap
void demo_swap()
{
    std::list<int> lst1 = { 1, 2, 3 };
    std::list<int> lst2 = { 10, 20, 30, 40 };
    std::cout << "[swap] 交换前 lst1.size=" << lst1.size()
        << " lst2.size=" << lst2.size() << std::endl;
    lst1.swap(lst2);
    std::cout << "[swap] 交换后 lst1: ";
    for (const auto& val : lst1) std::cout << val << " ";
    std::cout << " | lst2: ";
    for (const auto& val : lst2) std::cout << val << " ";
    std::cout << std::endl;
}

// 8.2 比较操作符
void demo_comparison_operators()
{
    std::list<int> lst1 = { 1, 2, 3 };
    std::list<int> lst2 = { 1, 2, 3 };
    std::list<int> lst3 = { 1, 2, 4 };
    std::list<int> lst4 = { 1, 2 };

    std::cout << "[==] lst1 == lst2: " << (lst1 == lst2) << std::endl;
    std::cout << "[!=] lst1 != lst3: " << (lst1 != lst3) << std::endl;
    std::cout << "[<] lst1 < lst3: " << (lst1 < lst3) << std::endl;
    std::cout << "[>] lst3 > lst1: " << (lst3 > lst1) << std::endl;
    std::cout << "[<=] lst1 <= lst2: " << (lst1 <= lst2) << std::endl;
    std::cout << "[>=] lst1 >= lst4: " << (lst1 >= lst4) << std::endl;
}

// ====================================================================

/*
 * 9. 遍历方式
 */

// 9.1 范围遍历
void demo_range_for()
{
    std::list<int> lst = { 10, 20, 30, 40, 50 };
    std::cout << "[范围for-只读] ";
    for (const auto& val : lst) std::cout << val << " ";
    std::cout << std::endl;

    std::cout << "[范围for-修改] ";
    for (auto& val : lst)
    {
        val += 1;
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

// 9.2 迭代器遍历
void demo_iterator_traversal()
{
    std::list<Student> students = {
        Student("Alice", 22, 95.5),
        Student("Bob", 21, 88.0),
        Student("Charlie", 23, 92.3)
    };
    std::cout << "[迭代器遍历] " << std::endl;
    for (auto it = students.begin(); it != students.end(); ++it)
    {
        std::cout << "  " << *it << std::endl;
    }
}

// 9.3 反向遍历
void demo_reverse_traversal()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    std::cout << "[反向遍历] ";
    for (auto it = lst.rbegin(); it != lst.rend(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// ====================================================================

/*
 * 10. 与算法配合
 */

// 10.1 查找 / 条件查找
void demo_find()
{
    std::list<int> lst = { 10, 20, 30, 40, 50 };
    auto it = std::find(lst.begin(), lst.end(), 30);
    if (it != lst.end())
    {
        std::cout << "[find] 找到30" << std::endl;
    }

    auto it2 = std::find_if(lst.begin(), lst.end(), [](int x) { return x > 25; });
    if (it2 != lst.end())
    {
        std::cout << "[find_if] 第一个>25的元素: " << *it2 << std::endl;
    }
}

// 10.2 计数 / 条件计数
void demo_count()
{
    std::list<int> lst = { 1, 2, 2, 3, 2, 4, 2, 5 };
    auto cnt = std::count(lst.begin(), lst.end(), 2);
    std::cout << "[count] 2出现次数: " << cnt << std::endl;

    auto cnt2 = std::count_if(lst.begin(), lst.end(), [](int x) { return x > 2; });
    std::cout << "[count_if] >2的元素个数: " << cnt2 << std::endl;
}

// 10.3 accumulate
void demo_accumulate()
{
    std::list<int> lst = { 1, 2, 3, 4, 5 };
    int sum = std::accumulate(lst.begin(), lst.end(), 0);
    std::cout << "[accumulate] 求和: " << sum << std::endl;

    int product = std::accumulate(lst.begin(), lst.end(), 1, std::multiplies<int>());
    std::cout << "[accumulate] 求积: " << product << std::endl;
}

// 10.4 for_each
void demo_for_each()
{
    std::list<Student> students = {
        Student("Alice", 22, 95.5),
        Student("Bob", 21, 88.0),
        Student("Charlie", 23, 92.3)
    };
    std::cout << "[for_each] " << std::endl;
    std::for_each(students.begin(), students.end(),
        [](const Student& s) {
            std::cout << "  " << s.getName() << "-" << s.getScore() << std::endl;
        });
}

// ====================================================================

/*
 * 11. 实战场景
 */

// 11.1 模拟FIFO消息队列
void demo_message_queue()
{
    std::list<Task> taskQueue;
    taskQueue.emplace_back(1, "写报告", 1);
    taskQueue.emplace_back(2, "发邮件", 1);
    taskQueue.emplace_back(3, "开会", 2);

    std::cout << "[消息队列-FIFO] 任务列表: " << std::endl;
    while (!taskQueue.empty())
    {
        std::cout << "  处理: " << taskQueue.front() << std::endl;
        taskQueue.pop_front();
    }
}

// 11.2 模拟LRU缓存
void demo_lru_cache()
{
    const size_t CAPACITY = 3;
    std::list<int> order;
    std::unordered_map<int, std::list<int>::iterator> cacheMap;

    auto access = [&](int key) {
        auto it = cacheMap.find(key);
        if (it != cacheMap.end())
        {
            order.erase(it->second);
            order.push_front(key);
            cacheMap[key] = order.begin();
            std::cout << "[LRU] 命中 key=" << key << std::endl;
        }
        else
        {
            if (order.size() >= CAPACITY)
            {
                int evict = order.back();
                order.pop_back();
                cacheMap.erase(evict);
                std::cout << "[LRU] 淘汰 key=" << evict << std::endl;
            }
            order.push_front(key);
            cacheMap[key] = order.begin();
            std::cout << "[LRU] 插入 key=" << key << std::endl;
        }
        };

    access(1); access(2); access(3);
    access(1); // 命中
    access(4); // 淘汰2
    access(2); // 淘汰3

    std::cout << "[LRU] 最终顺序: ";
    for (const auto& k : order) std::cout << k << " ";
    std::cout << std::endl;
}

// 多项式运算
struct PolyTerm
{
    double coeff;
    int exp;
    friend std::ostream& operator<<(std::ostream& os, const PolyTerm& t)
    {
        os << t.coeff << "x^" << t.exp;
        return os;
    }
};

void demo_polynomial()
{
    std::list<PolyTerm> poly1 = { {3.0, 3}, {2.0, 2}, {1.0, 0} };
    std::list<PolyTerm> poly2 = { {1.0, 3}, {-2.0, 2}, {5.0, 1} };

    // 简单合并同类项演示
    std::list<PolyTerm> result;
    auto it1 = poly1.begin();
    auto it2 = poly2.begin();

    while (it1 != poly1.end() && it2 != poly2.end())
    {
        if (it1->exp == it2->exp)
        {
            double c = it1->coeff + it2->coeff;
            if (c != 0.0) result.push_back({ c, it1->exp });
            ++it1; ++it2;
        }
        else if (it1->exp > it2->exp)
        {
            result.push_back(*it1);
            ++it1;
        }
        else
        {
            result.push_back(*it2);
            ++it2;
        }
    }
    while (it1 != poly1.end()) { result.push_back(*it1); ++it1; }
    while (it2 != poly2.end()) { result.push_back(*it2); ++it2; }

    std::cout << "[多项式加法] 结果: ";
    for (const auto& t : result) std::cout << t << " + ";
    std::cout << "0" << std::endl;
}

// ====================================================================

int main()
{
    std::cout << "========== 1. 构造函数 ==========" << std::endl;
    demo_default_constructor();
    demo_fill_constructor();
    demo_range_constructor();
    demo_copy_constructor();
    demo_move_constructor();
    demo_initializer_list_constructor();

    std::cout << "\n========== 2. 赋值操作 ==========" << std::endl;
    demo_copy_assignment();
    demo_move_assignment();
    demo_initializer_list_assignment();
    demo_assign_fill();
    demo_assign_range();
    demo_assign_initializer_list();

    std::cout << "\n========== 3. 元素访问 ==========" << std::endl;
    demo_front();
    demo_back();

    std::cout << "\n========== 4. 迭代器 ==========" << std::endl;
    demo_begin_end();
    demo_cbegin_cend();
    demo_rbegin_rend();
    demo_crbegin_crend();

    std::cout << "\n========== 5. 容量相关 ==========" << std::endl;
    demo_empty();
    demo_size();
    demo_max_size();

    std::cout << "\n========== 6. 修改操作 ==========" << std::endl;
    demo_clear();
    demo_insert_single();
    demo_insert_fill();
    demo_insert_range();
    demo_insert_initializer_list();
    demo_emplace();
    demo_erase_single();
    demo_erase_range();
    demo_push_back();
    demo_push_front();
    demo_emplace_back();
    demo_emplace_front();
    demo_pop_back();
    demo_pop_front();
    demo_resize();

    std::cout << "\n========== 7. list特有操作 ==========" << std::endl;
    demo_splice();
    demo_remove();
    demo_remove_if();
    demo_unique();
    demo_merge();
    demo_sort();
    demo_reverse();

    std::cout << "\n========== 8. swap与非成员函数 ==========" << std::endl;
    demo_swap();
    demo_comparison_operators();

    std::cout << "\n========== 9. 遍历方式 ==========" << std::endl;
    demo_range_for();
    demo_iterator_traversal();
    demo_reverse_traversal();

    std::cout << "\n========== 10. 与算法配合 ==========" << std::endl;
    demo_find();
    demo_count();
    demo_accumulate();
    demo_for_each();

    std::cout << "\n========== 11. 实战场景 ==========" << std::endl;
    demo_message_queue();
    demo_lru_cache();
    demo_polynomial();

    return 0;
}

【C++ STL】std::list

第一章 std::list 容器函数列表与讲解

一、构造函数

默认构造

填充构造

范围构造

拷贝构造

移动构造

初始化列表构造

二、赋值操作

operator=

assign (填充)

assign (范围)

assign (列表)

三、元素访问

front

back

四、迭代器

begin / end

cbegin / cend

rbegin / rend

crbegin / crend

五、容量相关

empty

size

max_size

六、修改操作

clear

insert

emplace

erase

push_back / push_front

emplace_back / emplace_front

pop_back / pop_front

resize

七、list 特有操作

splice

remove / remove_if

unique

merge

sort

reverse

八、swap 与非成员函数

swap

比较运算符

第二章 分模块代码解析

一、构造函数相关

二、赋值操作

三、元素访问

四、迭代器

五、容量相关

六、修改操作

七、list 特有操作

八、swap 与非成员函数

九、遍历方式

十、与算法配合

第三章 完整代码

`operator=`

`assign` (填充)

`assign` (范围)

`assign` (列表)

`front`

`back`

`begin` / `end`

`cbegin` / `cend`

`rbegin` / `rend`

`crbegin` / `crend`

`empty`

`size`

`max_size`

`clear`

`insert`

`emplace`

`erase`

`push_back` / `push_front`

`emplace_back` / `emplace_front`

`pop_back` / `pop_front`

`resize`

`splice`

`remove` / `remove_if`

`unique`

`merge`

`sort`

`reverse`

`swap`

第二章分模块代码解析

第三章完整代码