【C++】List容器（2）-内存管理-创建-插入-删除-遍历-排序-查找-底层分析-构造和析构函数-内存泄漏等

2024-04-15 12:36
文章标签 分析 遍历 c++ 函数 内存 创建 查找 管理 排序 构造 删除 底层 容器 list 插入 泄漏 和析构

本文主要是介绍【C++】List容器（2）-内存管理-创建-插入-删除-遍历-排序-查找-底层分析-构造和析构函数-内存泄漏等，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

std::list 是 C++ STL 中的一种双向链表容器，它提供了一系列的迭代器来访问元素，包括前方迭代器、后方迭代器和const迭代器。std::list 采用双向链表实现，每个节点都存储了数据以及两个指向前一个节点和后一个节点的指针。

内存管理

在 C++ 中，std::list 容器是由标准模板库（STL）管理的，这意味着开发者不需要手动管理其内存分配和释放。std::list 容器使用动态内存分配在内部维护一个双向链表，以适应元素的动态插入和删除。

代码举例

下面是一些使用 std::list 的示例代码，包括基本的操作如插入、删除、遍历等。

下面是一些关于std::list容器内存管理的代码示例和说明：

创建 List 容器
#include <iostream>  
#include <list>  int main() {  // 创建一个空的 int 类型的 list 容器  std::list<int> myList;  // 输出 list 的大小  std::cout << "Size of myList: " << myList.size() << std::endl; // 输出: 0  return 0;  
}
插入元素
#include <iostream>  
#include <list>  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 <iostream>  
#include <list>  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 <iostream>  
#include <list>  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 <iostream>  
#include <list>  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 <iostream>  
#include <list>  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 <iostream>  
#include <list>  
#include <algorithm>  int main() {  std::list<int> myList = {4, 2, 5, 1, 3};  // 对 list 进行排序  myList.sort();  // 查找元素  auto it = std::find(myList.begin(), myList.end(), 3);  if (it != myList.end()) {  std::cout << "Found " << *it << std::endl; // 输出: Found 3  } else {  std::cout << "Not found" << std::endl;  }  return 0;  
}

在以上示例中，std::list 自动管理其内部节点的内存分配和释放。当元素被插入时，新的节点会被创建；当元素被删除时，相应的节点会被释放。
当然可以，下面我将提供更多关于std::list容器的使用示例，并详细解释每个操作对内存管理的影响。

合并两个 List
#include <iostream>  
#include <list>  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 <iostream>  
#include <list>  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 的底层是由节点组成的双向链表。每个节点包含以下几个部分：

  1. 数据部分：存储容器的元素。
  2. 向前指针：指向链表中前一个节点的指针。
  3. 向后指针：指向链表中后一个节点的指针。
    这种数据结构使得 std::list 可以在常数时间内完成插入和删除操作（平均情况），因为这些操作只需要改变节点的指针。
内存分配

当创建 std::list 容器时，STL 会根据需要动态分配内存来创建链表的节点。这些节点会一直保留在内存中，直到容器被销毁。

插入操作

在 std::list 中插入元素时，STL 会执行以下步骤：

  1. 分配一个新的节点。
  2. 将新节点的数据部分设置为要插入的元素。
  3. 如果插入到链表尾部，则将新节点的向前指针设置为当前尾节点，并将当前尾节点的向后指针设置为新节点。如果插入到链表头部，则将新节点的向后指针设置为当前头节点，并将当前头节点的向前指针设置为新节点。
  4. 如果插入点在中间，则需要更新前一个节点的向后指针和后一个节点的向前指针，使它们都指向新节点。
删除操作

在 std::list 中删除元素时，STL 会执行以下步骤：

  1. 找到要删除的节点。
  2. 更新前一个节点的向后指针，使其指向要删除节点的后继节点。
  3. 更新后一个节点的向前指针，使其指向要删除节点的前驱节点。
  4. 释放要删除的节点所占用的内存。
内存释放

当 std::list 容器被销毁时，STL 会自动释放所有节点的内存。这是通过 std::list 的析构函数来完成的，它遍历整个链表，并逐个释放每个节点的内存。

std::list是一个双向链表，它通过动态分配内存来存储元素，每个元素都存储在一个单独的节点中。

构造函数和析构函数

std::list的构造函数负责分配内存来存储元素，而析构函数则负责释放这些内存。

#include <iostream>  
#include <list>  int main() {  // 构造函数分配内存  std::list<int> myList = {1, 2, 3};  // ... 进行一些操作 ...  // 析构函数释放内存  // 当myList离开作用域时，它的析构函数将被调用，自动释放所有节点的内存  
} // myList的析构函数在这里被调用
内存泄漏

由于std::list自动管理其内存，因此，在正常使用情况下，你不会遇到内存泄漏问题。但是，如果你在使用迭代器或指针时不够小心，可能会间接导致内存泄漏。

#include
#include

int main() {
std::list<int*> myList; // 列表存储int指针

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 <iostream>  
#include <list>  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 <iostream>  
#include <list>  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 容器不支持随机访问，因为它不是基于数组的容器。访问元素需要使用迭代器进行顺序遍历。

这篇关于【C++】List容器（2）-内存管理-创建-插入-删除-遍历-排序-查找-底层分析-构造和析构函数-内存泄漏等的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/905832。

相关文章

NameNode内存生产配置

NameNode内存生产配置

Hadoop2.x 系列，配置 NameNode 内存 NameNode 内存默认 2000m ，如果服务器内存 4G ， NameNode 内存可以配置 3g 。在 hadoop-env.sh 文件中配置如下。 HADOOP_NAMENODE_OPTS=-Xmx3072m Hadoop3.x 系列，配置 Nam
阅读更多...
【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
性能分析之MySQL索引实战案例

性能分析之MySQL索引实战案例

文章目录 一、前言二、准备三、MySQL索引优化四、MySQL 索引知识回顾五、总结 一、前言 在上一讲性能工具之 JProfiler 简单登录案例分析实战中已经发现SQL没有建立索引问题，本文将一起从代码层去分析为什么没有建立索引？ 开源ERP项目地址：https://gitee.com/jishenghua/JSH_ERP 二、准备 打开IDEA找到登录请求资源路径位置
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动，这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升：减少抖动，提高图像的清晰度和细节表现力，使得监控画面更加真实可信。 - 细节增强：在低光条件下，抖
阅读更多...
电脑桌面文件删除了怎么找回来？别急，快速恢复攻略在此

电脑桌面文件删除了怎么找回来？别急，快速恢复攻略在此

在日常使用电脑的过程中，我们经常会遇到这样的情况：一不小心，桌面上的某个重要文件被删除了。这时，大多数人可能会感到惊慌失措，不知所措。 其实，不必过于担心，因为有很多方法可以帮助我们找回被删除的桌面文件。下面，就让我们一起来了解一下这些恢复桌面文件的方法吧。 一、使用撤销操作 如果我们刚刚删除了桌面上的文件，并且还没有进行其他操作，那么可以尝试使用撤销操作来恢复文件。在键盘上同时按下“C
阅读更多...
hdu1171（母函数或多重背包）

hdu1171（母函数或多重背包）

题意：把物品分成两份，使得价值最接近 可以用背包，或者是母函数来解，母函数（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v） 其中指数为价值，每一项的数目为（该物品数+1）个 代码如下： #include<iostream>#include<algorithm>
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2