【C++】List容器（2）-内存管理-创建-插入-删除-遍历-排序-查找-底层分析-构造和析构函数-内存泄漏等
std::list 是 C++ STL 中的一种双向链表容器，它提供了一系列的迭代器来访问元素，包括前方迭代器、后方迭代器和const迭代器。std::list 采用双向链表实现，每个节点都存储了数据以及两个指向前一个节点和后一个节点的指针。
内存管理
在 C++ 中，std::list 容器是由标准模板库（STL）管理的，这意味着开发者不需要手动管理其内存分配和释放。std::list 容器使用动态内存分配在内部维护一个双向链表，以适应元素的动态插入和删除。
代码举例
下面是一些使用 std::list 的示例代码，包括基本的操作如插入、删除、遍历等。
下面是一些关于std::list容器内存管理的代码示例和说明：
创建 List 容器
#include
int main() {
// 创建一个空的 int 类型的 list 容器
std::list<int> myList;
// 输出 list 的大小
std::cout << "Size of myList: " << myList.size() << std::endl; // 输出: 0
return 0;
}
插入元素
#include
int main() {
std::list<int> myList;
// 在链表尾部插入元素
myList.push_back(1);
myList.push_back(2);
myList.push_back(3);
// 在链表头部插入元素
myList.push_front(0);
// 在指定位置插入元素
auto it = myList.begin();
std::advance(it, 2); // 将迭代器移动到第3个元素位置
myList.insert(it, 2.5); // 在第3个位置插入一个浮点数（注意：这里会发生类型转换）
// 输出 list 的内容
for (int num : myList) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 0 1 2 2 3
return 0;
}
#include
int main() {
std::list<int> myList;
// 在链表尾部插入元素
myList.push_back(1); // 分配一个新的节点，并将1存入其中，然后将该节点添加到链表尾部
// 在链表头部插入元素
myList.push_front(0); // 分配一个新的节点，并将0存入其中，然后将该节点添加到链表头部
// 在指定位置插入元素
auto it = myList.begin();
std::advance(it, 1); // 将迭代器移动到第2个元素位置
myList.insert(it, 2); // 分配一个新的节点，并将2存入其中，然后将该节点插入到迭代器it所指向的位置
// 输出 list 的内容
for (const auto& num : myList) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 0 2 1
return 0;
}
删除元素
#include
int main() {
std::list<int> myList = {0, 1, 2, 3, 4};
// 删除指定值的元素
myList.remove(2); // 删除所有值为2的元素
// 删除指定位置的元素
auto it = myList.begin();
std::advance(it, 2); // 将迭代器移动到第3个元素位置
myList.erase(it); // 删除第3个元素
// 输出 list 的内容
for (int num : myList) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 0 1 3 4
return 0;
}
#include
int main() {
std::list<int> myList = {0, 1, 2, 3, 4};
// 删除链表头部的元素
myList.pop_front(); // 删除链表头部的节点，并释放其内存
// 删除链表尾部的元素
myList.pop_back(); // 删除链表尾部的节点，并释放其内存
// 删除指定位置的元素
auto it = myList.begin();
std::advance(it, 1); // 将迭代器移动到第2个元素位置
myList.erase(it); // 删除迭代器it所指向的节点，并释放其内存
// 删除所有值为特定值的元素
myList.remove(3); // 遍历链表，删除所有值为3的节点，并释放它们的内存
// 输出 list 的内容
for (const auto& num : myList) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 1 （假设列表中只有一个1）
return 0;
}
遍历元素
#include
int main() {
std::list<int> myList = {0, 1, 2, 3, 4};
// 使用迭代器遍历 list
for (std::list<int>::iterator it = myList.begin(); it != myList.end(); ++it) {
std::cout << *it << ' ';
}
std::cout << std::endl; // 输出: 0 1 2 3 4
// 使用范围基础的 for循环遍历 list
for (const auto& num : myList) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 0 1 2 3 4
return 0;
}
排序和查找
#include
#include 在以上示例中，std::list 自动管理其内部节点的内存分配和释放。当元素被插入时，新的节点会被创建；当元素被删除时，相应的节点会被释放。
当然可以，下面我将提供更多关于std::list容器的使用示例，并详细解释每个操作对内存管理的影响。
合并两个 List
#include
int main() {
std::list<int> list1 = {1, 2, 3};
std::list<int> list2 = {4, 5, 6};
// 合并两个 list，将 list2 的所有元素移动到 list1 的尾部
list1.splice(list1.end(), list2);
// 输出合并后的 list1 的内容
for (const auto& num : list1) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 1 2 3 4 5 6
// 注意：splice 操作并不会释放 list2 中节点的内存，而是将它们移动到 list1 中
// 因此，操作后 list2 为空，但其内存仍然被分配着
return 0;
}
拷贝和赋值
#include
int main() {
std::list<int> list1 = {1, 2, 3};
// 拷贝构造一个新的 list
std::list<int> list2(list1); // 分配新的节点，并将 list1 中的元素复制到这些新节点中
// 赋值操作
std::list<int> list3;
list3 = list1; // 分配新的节点（如果 list3 中原有节点，则先释放它们），并将 list1 中的元素复制到这些新节点中
// 输出 list2 和 list3 的内容
for (const auto& num : list2) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 1 2 3
for (const auto& num : list3) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 1 2 3
return 0;
}
底层分析
std::list 是 C++ STL 中的一种容器，它使用动态内存分配在内部维护一个双向链表。下面是对其底层内存管理的更深入的讲解。
数据结构
std::list 的底层是由节点组成的双向链表。每个节点包含以下几个部分：
- 数据部分：存储容器的元素。
- 向前指针：指向链表中前一个节点的指针。
- 向后指针：指向链表中后一个节点的指针。
这种数据结构使得std::list可以在常数时间内完成插入和删除操作（平均情况），因为这些操作只需要改变节点的指针。
内存分配
当创建 std::list 容器时，STL 会根据需要动态分配内存来创建链表的节点。这些节点会一直保留在内存中，直到容器被销毁。
插入操作
在 std::list 中插入元素时，STL 会执行以下步骤：
- 分配一个新的节点。
- 将新节点的数据部分设置为要插入的元素。
- 如果插入到链表尾部，则将新节点的向前指针设置为当前尾节点，并将当前尾节点的向后指针设置为新节点。如果插入到链表头部，则将新节点的向后指针设置为当前头节点，并将当前头节点的向前指针设置为新节点。
- 如果插入点在中间，则需要更新前一个节点的向后指针和后一个节点的向前指针，使它们都指向新节点。
删除操作
在 std::list 中删除元素时，STL 会执行以下步骤：
- 找到要删除的节点。
- 更新前一个节点的向后指针，使其指向要删除节点的后继节点。
- 更新后一个节点的向前指针，使其指向要删除节点的前驱节点。
- 释放要删除的节点所占用的内存。
内存释放
当 std::list 容器被销毁时，STL 会自动释放所有节点的内存。这是通过 std::list 的析构函数来完成的，它遍历整个链表，并逐个释放每个节点的内存。
std::list是一个双向链表，它通过动态分配内存来存储元素，每个元素都存储在一个单独的节点中。
构造函数和析构函数
std::list的构造函数负责分配内存来存储元素，而析构函数则负责释放这些内存。
#include
int main() {
// 构造函数分配内存
std::list<int> myList = {1, 2, 3};
// ... 进行一些操作 ...
// 析构函数释放内存
// 当myList离开作用域时，它的析构函数将被调用，自动释放所有节点的内存
} // myList的析构函数在这里被调用
内存泄漏
由于std::list自动管理其内存，因此，在正常使用情况下，你不会遇到内存泄漏问题。但是，如果你在使用迭代器或指针时不够小心，可能会间接导致内存泄漏。
#include
#include
int main() {
std::list
int* ptr = new int(5); // 动态分配内存
myList.push_back(ptr); // 将指针添加到列表中
// ... 进行一些操作 ...
// 忘记释放动态分配的内存将导致内存泄漏
// 正确的做法是在删除指针之前先释放它指向的内存
delete ptr; // 释放内存
ptr = nullptr; // 将指针置为空，避免悬挂指针
// 现在可以安全地从列表中删除指针
myList.remove(ptr);
return 0;
}
在这个例子中，我们创建了一个存储int*的std::list。当我们向列表中添加一个动态分配的int的指针时，必须确保在不再需要该int时释放其内存。否则，就会发生内存泄漏。
交换和移动语义
C++11引入了移动语义，它允许在不复制数据的情况下转移资源所有权。std::list支持移动操作，这可以提高效率并减少不必要的内存分配和释放。
#include
int main() {
std::list<int> list1 = {1, 2, 3};
std::list<int> list2;
// 移动赋值操作
list2 = std::move(list1); // list1的资源被转移到list2，list1变为空列表
// 输出 list2 的内容
for (const auto& num : list2) {
std::cout << num << ' ';
}
std::cout << std::endl; // 输出: 1 2 3
// list1现在是空的
return 0;
}
在移动赋值操作中，list1中的资源（即节点）被转移到list2中，而list1则变为一个空列表，不再拥有任何元素。这避免了不必要的复制操作，提高了性能。
容量和大小
你可以使用std::list的成员函数来检查其容量和大小。
#include
int main() {
std::list<int> myList = {1, 2, 3};
// 获取列表的大小
std::size_t size = myList.size();
std::cout << "Size of myList: " << size << std::endl; // 输出: Size of myList: 3
// 获取列表的最大可能大小（对于list来说，这个值通常没有意义，因为list可以动态增长）
std::size_t max_size = myList.max_size();
std::cout << "Max size of myList: " << max_size << std::endl; // 输出一个很大的数，表示理论上的最大容量
return 0;
}
这些操作并不直接影响std::list的内存管理，但它们提供了关于容器当前状态的有用信息。
综上所述，std::list通过其内部机制自动管理节点的内存分配和释放，用户通常不需要直接干预这个过程。然而，理解这些机制有助于避免常见的内存管理错误，如内存泄漏和悬挂指针。在使用std::list时，应始终确保遵循良好的编程实践，如避免不必要的动态内存分配和正确管理指针。
注意事项
- 由于
std::list使用动态内存分配，因此在容器生命周期内，内存分配和释放操作是自动完成的，不需要手动管理。 - 在进行插入和删除操作时，需要注意迭代器的失效问题。特别是在执行删除操作后，指向被删除节点的迭代器、指针和引用都会失效。
std::list容器不支持随机访问，因为它不是基于数组的容器。访问元素需要使用迭代器进行顺序遍历。