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

相关文章

Windows下C++使用SQLitede的操作过程

Windows下C++使用SQLitede的操作过程

《Windows下C++使用SQLitede的操作过程》本文介绍了Windows下C++使用SQLite的安装配置、CppSQLite库封装优势、核心功能（如数据库连接、事务管理）、跨平台支持及性能优... 目录Windows下C++使用SQLite1、安装2、代码示例CppSQLite：C++轻松操作SQ
阅读更多...
C++中RAII资源获取即初始化

C++中RAII资源获取即初始化

《C++中RAII资源获取即初始化》RAII通过构造/析构自动管理资源生命周期,确保安全释放,本文就来介绍一下C++中的RAII技术及其应用,具有一定的参考价值,感兴趣的可以了解一下... 目录一、核心原理与机制二、标准库中的RAII实现三、自定义RAII类设计原则四、常见应用场景1. 内存管理2. 文件操
阅读更多...
C++中零拷贝的多种实现方式

C++中零拷贝的多种实现方式

《C++中零拷贝的多种实现方式》本文主要介绍了C++中零拷贝的实现示例,旨在在减少数据在内存中的不必要复制,从而提高程序性能、降低内存使用并减少CPU消耗,零拷贝技术通过多种方式实现,下面就来了解一下... 目录一、C++中零拷贝技术的核心概念二、std::string_view 简介三、std::stri
阅读更多...
C++高效内存池实现减少动态分配开销的解决方案

C++高效内存池实现减少动态分配开销的解决方案

《C++高效内存池实现减少动态分配开销的解决方案》C++动态内存分配存在系统调用开销、碎片化和锁竞争等性能问题,内存池通过预分配、分块管理和缓存复用解决这些问题,下面就来了解一下... 目录一、C++内存分配的性能挑战二、内存池技术的核心原理三、主流内存池实现：TCMalloc与Jemalloc1. TCM
阅读更多...
Python中help()和dir()函数的使用

Python中help()和dir()函数的使用

《Python中help()和dir()函数的使用》我们经常需要查看某个对象（如模块、类、函数等）的属性和方法,Python提供了两个内置函数help()和dir(),它们可以帮助我们快速了解代... 目录1. 引言2. help() 函数2.1 作用2.2 使用方法2.3 示例(1) 查看内置函数的帮助(
阅读更多...
Python中使用uv创建环境及原理举例详解

Python中使用uv创建环境及原理举例详解

《Python中使用uv创建环境及原理举例详解》uv是Astral团队开发的高性能Python工具,整合包管理、虚拟环境、Python版本控制等功能,：本文主要介绍Python中使用uv创建环境及... 目录一、uv工具简介核心特点：二、安装uv1. 通过pip安装2. 通过脚本安装验证安装：配置镜像源（可
阅读更多...
C++ 函数 strftime 和时间格式示例详解

C++ 函数 strftime 和时间格式示例详解

《C++函数strftime和时间格式示例详解》strftime是C/C++标准库中用于格式化日期和时间的函数,定义在ctime头文件中,它将tm结构体中的时间信息转换为指定格式的字符串,是处理... 目录C++ 函数 strftipythonme 详解一、函数原型二、功能描述三、格式字符串说明四、返回值五
阅读更多...
使用jenv工具管理多个JDK版本的方法步骤

使用jenv工具管理多个JDK版本的方法步骤

《使用jenv工具管理多个JDK版本的方法步骤》jenv是一个开源的Java环境管理工具,旨在帮助开发者在同一台机器上轻松管理和切换多个Java版本,：本文主要介绍使用jenv工具管理多个JD... 目录一、jenv到底是干啥的？二、jenv的核心功能（一）管理多个Java版本（二）支持插件扩展（三）环境隔
阅读更多...
MySQL存储过程之循环遍历查询的结果集详解

MySQL存储过程之循环遍历查询的结果集详解

《MySQL存储过程之循环遍历查询的结果集详解》：本文主要介绍MySQL存储过程之循环遍历查询的结果集,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录前言1. 表结构2. 存储过程3. 关于存储过程的SQL补充总结前言近来碰到这样一个问题：在生产上导入的数据发现
阅读更多...
MyBatis Plus 中 update_time 字段自动填充失效的原因分析及解决方案(最新整理)

MyBatis Plus 中 update_time 字段自动填充失效的原因分析及解决方案(最新整理)

《MyBatisPlus中update_time字段自动填充失效的原因分析及解决方案(最新整理)》在使用MyBatisPlus时,通常我们会在数据库表中设置create_time和update... 目录前言一、问题现象二、原因分析三、总结：常见原因与解决方法对照表四、推荐写法前言在使用 MyBATis
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2