C/C++内存管理

最新推荐文章于 2024-10-09 17:48:08 发布

没事就去码

最新推荐文章于 2024-10-09 17:48:08 发布

阅读量1k

点赞数 23

文章标签： jvm

本文链接：https://blog.csdn.net/2305_81151565/article/details/141864576

版权

内存存储

首先我们来看一看C/C++的内存分布。现阶段我们理解到了栈和堆比较多，调用函数会开辟栈帧，如果有资源的申请，则会在堆上面申请。因为堆上的内存相对来说分配的比较多，而栈上的内存分配的比较少。所以为什么有的时候，我们递归深度太深，会导致栈溢出。

然后就是数据段，它会存储我们的全局数据和静态的数据，代码段会存储常量和可执行代码。

通过上面这幅图，应该就能清楚的看出平时我们写的数据的存储情况。

说明：栈又叫堆栈——非静态局部变量/函数参数/返回值等等，栈是向下增长的。

堆用于程序运行时的动态分配，堆是可以向上增长的。

数据段存储全局数据和静态数据。

代码段——可执行代码和只读常量。

C语言中动态内存管理方式：malloc，calloc，realloc，free

功能：
- malloc(size_t size)：分配一块指定大小的内存，但不初始化这块内存。返回的是指向这块内存的指针。
- calloc(size_t num, size_t size)：分配一块内存，大小为 num * size，并将这块内存初始化为零。返回的是指向这块内存的指针。
- realloc(void *ptr, size_t size)：重新调整之前分配的内存块的大小。如果 ptr 为 NULL，则相当于调用 malloc；如果 size 为 0，则相当于调用 free。
参数：
- malloc 只需要一个参数，即所需内存的字节数。
- calloc 需要两个参数：元素的数量和每个元素的大小。
- realloc 需要两个参数：指向之前分配内存的指针和新的大小。
初始化：
- malloc 分配的内存内容是未定义的，可能包含垃圾值。
- calloc 分配的内存内容被初始化为零。
- realloc 的行为取决于原始内存块的内容，新的内存区域可能包含未定义的值。
返回值：
- 如果内存分配成功，malloc 和 calloc 返回指向分配内存的指针；如果失败，返回 NULL。
- realloc 如果成功，返回指向新内存的指针；如果失败，返回 NULL，并且原来的内存块保持不变。

这些函数在动态内存管理中非常重要，理解它们的区别有助于有效地管理内存。

malloc实现原理

malloc 的实现原理涉及动态内存分配的多个方面，包括内存管理、分配策略和数据结构。以下是 malloc 的基本实现原理：

内存池：
- malloc 通常在程序启动时向操作系统请求一块大的内存区域，称为内存池。这块内存池用于后续的动态内存分配。
空闲链表：
- malloc 使用数据结构（如空闲链表）来跟踪已分配和未分配的内存块。每个内存块通常包含一个头部，记录块的大小和状态（已分配或未分配）。
分配策略：
- malloc 采用不同的策略来选择合适的空闲块进行分配，常见的策略包括：
  - 首次适应（First Fit）：从空闲链表中找到第一个足够大的空闲块进行分配。
  - 最佳适应（Best Fit）：寻找最小的足够大的空闲块，以减少内存浪费。
  - 最差适应（Worst Fit）：选择最大的空闲块，以便留下较大的剩余空间。
内存对齐：
- 为了提高性能，malloc 通常会对内存块进行对齐（alignment），确保返回的指针满足特定的对齐要求（如 8 字节或 16 字节对齐）。
合并空闲块：
- 当释放内存时，malloc 会检查相邻的空闲块，如果它们是连续的，则将它们合并成一个更大的空闲块，以减少内存碎片。
系统调用：
- 当请求的内存超过当前可用的内存池时，malloc 会通过系统调用（如 sbrk 或 mmap）向操作系统请求更多的内存。
错误处理：
- 如果内存分配失败，malloc 会返回 NULL，程序员需要检查返回值以避免使用空指针。

这些原理和策略共同作用，使得 malloc 能够高效地管理动态内存分配，满足程序的需求。不同的 C 标准库实现可能会有不同的优化和策略，但基本原理大致相同。

C++内存管理方式

C语言中的内存管理方式在C++中还是可以继续使用，因为C++兼容C语言，但有些地方就无能为力，而且使用起来比较麻烦，因此C++拥有自己的一套内存管理的方式：通过new和delete操作符进行动态内存管理。

new和delete操作内置类型

这和C语言有很大的不同，C语言的代码来说相对复杂，而且还不能初始化，而在C++中，在分配空间的时候就可以初始化，方便了许多。

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete [],注意：匹配起来使用，否则会崩溃。

new和delete操作自定义类型

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class A
{	
public:
	//构造函数
	A(int a = 1)
		:_a(a)
	{
		cout << "构造函数" << endl;
	}

		~A()
	{
		cout << "析构函数" << endl;
	}
private :
	int _a;
};
int main()
{	
	A* tmp1 = (A*)malloc(sizeof(A));
	A* tmp2 = new A(10);
	free(tmp1);
	cout << "####" << endl;
	delete(tmp2);

	return 0;
}

可以看到，我们使用new的时候，它会自动调用构造函数去初始化成员变量，当我们使用delete的时候它会自动调用析构函数。但是对于内置类型它们几乎是一样的。

operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过 operator delete全局函数来释放空间。

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
 // try to allocate size bytes
 void *p;
 while ((p = malloc(size)) == 0)
     if (_callnewh(size) == 0)
     {
         // report no memory
         // 如果申请内存失败了，这里会抛出bad_alloc 类型异常
         static const std::bad_alloc nomem;
         _RAISE(nomem);
     }
 return (p);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void *pUserData)
{
     _CrtMemBlockHeader * pHead;
     RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
     if (pUserData == NULL)
         return;
     _mlock(_HEAP_LOCK);  /* block other threads */
     __TRY
         /* get a pointer to memory block header */
         pHead = pHdr(pUserData);
          /* verify block type */
         _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
         _free_dbg( pUserData, pHead->nBlockUse );
     __FINALLY
         _munlock(_HEAP_LOCK);  /* release other threads */
     __END_TRY_FINALLY
     return;
}
/*
free的实现
*/
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

通过两个全局函数，operator new底层实际上还是通过malloc来申请空间，如果申请成功就直接返回，否则就提供空间不足的应对措施（如抛异常）。operator delete 最终也是通过free来释放空间的。

new和delete的实现原理

内置类型

如果是申请内置类型的空间的话，那么malloc和new，delete和free基本相似，不同的地方是，new/delete申请和释放的是单个元素空间，new[]和delete[]申请的是连续空间，而且new在申请失败会抛异常，malloc会返回NULL。

自定义类型

new的原理

1.首先调用operator new 申请空间

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

delete的原理

1.在空间是行调用析构函数，完成对对象的资源清理工作

2.调佣operator new函数释放对象的空间

new T[n]的原理

1.调用operator new []函数，实际上是调用operator new 对N个对象进行空间申请

2.再在申请的空间上完成N次构造函数

delete []的原理

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

2.调用operator delete[] 释放空间，实际上还是调用operator delete []来释放空间

malloc/free和new/delete的区别

malloc/free 和 new/delete 是 C 和 C++ 中用于动态内存管理的两种不同机制。它们之间有几个关键区别：

语言：
- malloc/free 是 C 语言的内存管理函数，也可以在 C++ 中使用。
- new/delete 是 C++ 的内存管理运算符，专为 C++ 设计。
类型安全：
- malloc 返回 void* 类型的指针，需要手动转换为所需类型。
- new 返回所请求类型的指针，提供类型安全。
构造与析构：
- malloc 仅分配内存，不调用构造函数。
- new 除了分配内存外，还会调用对象的构造函数。
- free 不调用析构函数。
- delete 除了释放内存外，还会调用对象的析构函数。
内存分配失败的处理：
- malloc 在分配失败时返回 NULL。
- new 在分配失败时会抛出 std::bad_alloc 异常（除非使用 new(std::nothrow)，此时返回 nullptr）。
使用方式：
- malloc 和 free 的使用方式是
  void* ptr = malloc(size); free(ptr);
- new 和 delete 的使用方式是：
  MyClass* obj = new MyClass(); delete obj;