内存管理（C/C++）

分类:热门推荐日期:2024-04-23浏览:1评论:0

✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅

✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿

🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟

🌟🌟 追风赶月莫停留 🌟🌟

🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀

🌟🌟 平芜尽处是春山🌟🌟

🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟

🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿

✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅

🍋内存管理

  • 🍑C与C++内存分布
  • 🍑C语言中动态内存管理
  • 🍑C++中内存管理
    • 🍍new与delete对内置类型的处理
    • 🍍new与delete对自定义类型的处理
    • 🍍operator new与operator delete函数
    • 🍑new与delete的实现原理
      • 🍍内置类型
      • 🍍自定义类型
      • 🍑常见面试题（关于本章知识点）
        • 🍍 malloc与free和new与delete的区别
        • 🍍内存泄漏
        • 🍍如何避免内存泄漏

          🍑C与C++内存分布

          内存管理中大致可以分为五大区：

          1. 栈：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区的数据，在函数返回后，这块内存自动释放。栈是向下增长的
          2. 内存映射段：高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口，创建共享共享内存，做进程间通信。
          3. 堆：用于程序运行时动态内存分配，堆是可以上增长的。
          4. 数据段：存储全局数据和静态数据。
          5. 代码段：可执行的代码/只读常量。

          🍑C语言中动态内存管理

          int* p1 = (int*)malloc(sizeof(int));
int* p2 = (int*)realloc(p1, sizof(int)*4);
int* p3 = (int*)calloc(2, sizeof(int));
free(p1);
free(p2);
free(p3);

          上面三行代码就是在C语言中的动态开辟。

          malloc()：开辟一段空间，开辟的空间都是未初始化的，会被编译器赋值为随机值。

          calloc()：第一个参数是空间开辟的数量，第二个参数是空间开辟的类型，开辟的空间有初始值，为0。

          realloc()：可以自己开辟空间，也可以对已有空间进行扩容，会被初始化，为0。

          如果需要更详细的C语言内存管理介绍，请查略：动态内存管理（C语言）

          🍑C++中内存管理

          C语言动态内存开辟的规则在C++中依然适用，只不过C++场景更复杂，有一些规则不太适用于C++，所以在C++中提出了新的方式：通过new和delete操作符进行动态内存管理。

          🍍new与delete对内置类型的处理

          int main()
{ int* p1 = new int;
  
  int* p2 = new int(10);
  
  int* p3 = new int[3];
  delete p1;
  delete p2;
  delete[] p3;
}

          上图就是new与delete对内置类型的处理

          注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用

          new[]和delete[]，注意：匹配起来使用。

          🍍new与delete对自定义类型的处理

          class Tist
{public:
 Tist(int a = 0)
 : _a(a)
 { cout << "Tist():" << this << endl;
 }
 ~Tist()
 { cout << "~Tist():" << this << endl;
 }
private:
 int _a;
};
int main()
{ Tist* p1 = (Tist*)malloc(sizeof(Tist));
 Tist* p2 = new Tist(1);
 free(p1);
 delete p2;
 
 // 内置类型是几乎是一样的
 int* p3 = (int*)malloc(sizeof(int)); 
 int* p4 = new int;
free(p3);
delete p4;
Tist* p5 = (Tist*)malloc(sizeof(Tist)*10);
 Tist* p6 = new Tist[10];
 free(p5);
 delete[] p6;
 return 0;
}

          从上面几幅图中可以看出new与delete 和 malloc与free最大区别是 new/delete对于自定义类型除了开空间还会调用构造函数和析构函数。

          注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与

          free不会。

          🍍operator new与operator delete函数

          通过上面，已经了解到new是C++用来内存开辟的一种新的方式，而delete是用来释放空间。而operator new和operator delete是系统提供的全局函数，operator new 和 operator delete 是 C++ 中的运算符重载函数，它们分别用于动态内存分配和释放，当你使用 new 关键字来创建一个对象时，operator new 会被调用以分配足够的内存空间来存储该对象；当你使用 delete 关键字来销毁一个对象时，operator delete 会被调用以释放之前分配的内存。

          operator new 通常用于分配指定大小的内存。其默认实现通常使用 malloc 或类似的系统调用来完成。就是operator new函数也是通过C语言中malloc来申请空间的，当然也有一点区别，malloc申请失败是直接返回，而operator new申请失败是会抛异常。

          void* operator new(size_t size)
{void* p1 = (void*)malloc(sizeof(void));
	if (p1 == nullptr)
	{throw std::bad_alloc();//申请失败就抛异常
	}
	return p1;
}

          operator delete 用于释放之前通过 new 分配的内存。其默认实现也是通过free来完成释放空间。

          void operator delete(void* p1)
{free(p);
}

          🍑new与delete的实现原理

          🍍内置类型

          1. 内存分配：new 会向操作系统请求分配指定大小的内存。这个大小通常是你要创建的对象的大小。对于内置类型，大小是固定的，可以通过 sizeof 运算符获得。
          2. 返回指针：如果内存分配成功，new 会返回一个指向新分配内存的指针。如果内存分配失败（例如，因为系统内存不足），new 会抛出一个 std::bad_alloc 异常。

          🍍自定义类型

          1. new的原理

            （1）调用operator new函数申请空间。

            （2）在申请的空间上执行构造函数，完成对象的构造。

          2. delete的原理

            （1）在空间上执行析构函数，完成对象中资源的清理工作。

            （2）调用operator delete函数释放对象的空间。

          3. new T[N]的原理

            （1）调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请。

            （2）在申请的空间上执行N次构造函数。

          4. delete[]的原理

            （1）在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理。

            （2）调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间。

          🍑常见面试题（关于本章知识点）

          🍍 malloc与free和new与delete的区别

          malloc/free和new/delete

          共同点：都是从堆上申请空间，并且需要用户手动释放。

          不同点：

          1. malloc和free是函数，new和delete是操作符。
          2. malloc申请的空间不会初始化，new可以初始化。
          3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可。
          4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型。
          5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常。
          6. 申请自定义类型对象时，malloc与free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。

          🍍内存泄漏

          内存泄漏是指在程序运行过程中动态分配的内存没有被正确地释放，从而导致该部分内存持续占用系统资源，甚至在程序终止后仍然无法被系统回收。

          C++中，使用new分配的内存如果没有通过delete来释放，就会发生内存泄漏。

          如：

          int main()
{int* p1 = new int;// 没有进行释放就会导致内存泄漏
	
	return 0;
}

          内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

          C++中，内存泄漏通常发生在以下几种情况：

          1. 忘记释放内存：程序员可能在使用new分配内存后，由于疏忽或其他原因，忘记了使用delete来释放它。

          2. 异常安全：如果在分配内存后，程序抛出了异常，并且没有适当的异常处理来确保内存被释放，那么就会发生内存泄漏。

          3. 循环引用：在使用智能指针或对象关系图时，如果存在循环引用且没有正确的管理机制，可能导致对象无法被正常销毁，进而造成内存泄漏。

          4. 使用第三方库：第三方库可能存在内存管理问题，如果没有正确集成或调用这些库，也可能导致内存泄漏。

          🍍如何避免内存泄漏

          为了检测和修复内存泄漏，可以使用以下几种方法：

          1. 静态分析工具：使用静态代码分析工具来检查代码中潜在的内存泄漏。
          2. 动态分析工具：运行程序并使用内存分析器（如Valgrind的Memcheck工具）来检测内存泄漏。
          3. 智能指针：使用C++11及以后版本的智能指针（如std::unique_ptr和std::shared_ptr）来自动管理内存，减少手动管理内存的需求。
          4. RAII（资源获取即初始化）：将资源（如动态分配的内存）的生命周期绑定到对象的生命周期上，当对象被销毁时，自动释放资源。
          5. 通过遵循良好的编程实践和使用现代C++特性，可以大大降低内存泄漏的风险。

          关于本章的知识点就介绍完毕，如有疏漏或文中有错误，欢迎大家指针，谢谢！！！

相关推荐

关于我们常见问题广告服务免责声明联系我们
Powered By Z-BlogPHP 1.7.3 Theme By 优美主题
Copyright Your WebSite.Some Rights Reserved. 浙ICP备2023018783号