【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。

相关文章

C++使用栈实现括号匹配的代码详解

C++使用栈实现括号匹配的代码详解

《C++使用栈实现括号匹配的代码详解》在编程中,括号匹配是一个常见问题,尤其是在处理数学表达式、编译器解析等任务时,栈是一种非常适合处理此类问题的数据结构,能够精确地管理括号的匹配问题,本文将通过C+... 目录引言问题描述代码讲解代码解析栈的状态表示测试总结引言在编程中，括号匹配是一个常见问题，尤其是在
阅读更多...
使用C++实现链表元素的反转

使用C++实现链表元素的反转

《使用C++实现链表元素的反转》反转链表是链表操作中一个经典的问题,也是面试中常见的考题,本文将从思路到实现一步步地讲解如何实现链表的反转,帮助初学者理解这一操作,我们将使用C++代码演示具体实现,同... 目录问题定义思路分析代码实现带头节点的链表代码讲解其他实现方式时间和空间复杂度分析总结问题定义给定
阅读更多...
Android 悬浮窗开发示例((动态权限请求 | 前台服务和通知 | 悬浮窗创建 )

Android 悬浮窗开发示例((动态权限请求 | 前台服务和通知 | 悬浮窗创建 )

《Android悬浮窗开发示例((动态权限请求|前台服务和通知|悬浮窗创建)》本文介绍了Android悬浮窗的实现效果,包括动态权限请求、前台服务和通知的使用,悬浮窗权限需要动态申请并引导... 目录一、悬浮窗 动态权限请求1、动态请求权限2、悬浮窗权限说明3、检查动态权限4、申请动态权限5、权限设置完毕后
阅读更多...
C++初始化数组的几种常见方法(简单易懂)

C++初始化数组的几种常见方法(简单易懂)

《C++初始化数组的几种常见方法(简单易懂)》本文介绍了C++中数组的初始化方法,包括一维数组和二维数组的初始化,以及用new动态初始化数组,在C++11及以上版本中,还提供了使用std::array... 目录1、初始化一维数组1.1、使用列表初始化（推荐方式）1.2、初始化部分列表1.3、使用std::
阅读更多...
C++ Primer 多维数组的使用

C++ Primer 多维数组的使用

《C++Primer多维数组的使用》本文主要介绍了多维数组在C++语言中的定义、初始化、下标引用以及使用范围for语句处理多维数组的方法,具有一定的参考价值,感兴趣的可以了解一下... 目录多维数组多维数组的初始化多维数组的下标引用使用范围for语句处理多维数组指针和多维数组多维数组严格来说,C++语言没
阅读更多...
Springboot中分析SQL性能的两种方式详解

Springboot中分析SQL性能的两种方式详解

《Springboot中分析SQL性能的两种方式详解》文章介绍了SQL性能分析的两种方式：MyBatis-Plus性能分析插件和p6spy框架,MyBatis-Plus插件配置简单,适用于开发和测试环... 目录SQL性能分析的两种方式:功能介绍实现方式:实现步骤:SQL性能分析的两种方式:功能介绍记录
阅读更多...
golang内存对齐的项目实践

golang内存对齐的项目实践

《golang内存对齐的项目实践》本文主要介绍了golang内存对齐的项目实践,内存对齐不仅有助于提高内存访问效率,还确保了与硬件接口的兼容性,是Go语言编程中不可忽视的重要优化手段,下面就来介绍一下... 目录一、结构体中的字段顺序与内存对齐二、内存对齐的原理与规则三、调整结构体字段顺序优化内存对齐四、内
阅读更多...
SpringBoot中使用 ThreadLocal 进行多线程上下文管理及注意事项小结

SpringBoot中使用 ThreadLocal 进行多线程上下文管理及注意事项小结

《SpringBoot中使用ThreadLocal进行多线程上下文管理及注意事项小结》本文详细介绍了ThreadLocal的原理、使用场景和示例代码,并在SpringBoot中使用ThreadLo... 目录前言技术积累1.什么是 ThreadLocal2. ThreadLocal 的原理2.1 线程隔离2
阅读更多...
Python itertools中accumulate函数用法及使用运用详细讲解

Python itertools中accumulate函数用法及使用运用详细讲解

《Pythonitertools中accumulate函数用法及使用运用详细讲解》：本文主要介绍Python的itertools库中的accumulate函数,该函数可以计算累积和或通过指定函数... 目录1.1前言：1.2定义：1.3衍生用法：1.3Leetcode的实际运用:总结 1.1前言：本文将详
阅读更多...
最长公共子序列问题的深度分析与Java实现方式

最长公共子序列问题的深度分析与Java实现方式

《最长公共子序列问题的深度分析与Java实现方式》本文详细介绍了最长公共子序列（LCS）问题,包括其概念、暴力解法、动态规划解法,并提供了Java代码实现,暴力解法虽然简单,但在大数据处理中效率较低,... 目录最长公共子序列问题概述问题理解与示例分析暴力解法思路与示例代码动态规划解法DP 表的构建与意义动
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2