C/C++内存管理

C++忠实粉丝

于 2024-08-31 22:43:44 发布

阅读量1.5k

点赞数 35

分类专栏： C++语法学习文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/wer24_25/article/details/141759268

版权

C++语法学习专栏收录该内容

19 篇文章 0 订阅

订阅专栏

个人主页：C++忠实粉丝
欢迎点赞👍 收藏✨ 留言✉ 加关注💓本文由 C++忠实粉丝原创

C/C++内存管理

收录于专栏【C++语法基础】
本专栏旨在分享学习C++的一点学习笔记，欢迎大家在评论区交流讨论💌

1. C/C++内存分布

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

3. C++内存管理方式

3.1 new/delete操作内置类型

3.2 new和delete操作自定义类型

4. operator new与operator delete函数

4.1 operator new与operator delete函数

5. new和delete的实现原理

5.1 内置类型

5.2 自定义类型

6. 定位new表达式(placement-new)

7. malloc/free和new/delete的区别

我们先来看下面的一段代码和相关问题:

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	const char* pChar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof(int) * 4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
	free(ptr1);
	free(ptr3);
}

选择题：
选项 : A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____
staticGlobalVar在哪里？____
staticVar在哪里？____
localVar在哪里？____
num1 在哪里？____
char2在哪里？____
* char2在哪里？___
pChar3在哪里？____
* pChar3在哪里？____
ptr1在哪里？____
* ptr1在哪里？____

globalVar 和 staticGlobalVar 存储在数据段(静态区)，因为它们是全局变量或静态变量。C
staticVar 也是静态变量，但它的作用域限制在 Test() 函数中，因此也存储在数据段(静态区)。C
localVar 存储在栈，因为它是 Test() 函数的局部变量。A
num1 , char2 和* char2存储在栈，它们是局部变量和数组。A
pChar3 存储在栈，它是指针变量。A
* pChar3 存储在代码段(常量区)，因为 pChar3 指向一个字符串字面量。D
ptr1 存储在栈，它是指针变量。A
* ptr1 存储在堆，因为 ptr1 指向由 malloc 分配的内存区域。B

C/C++程序内存区域划分:

【说明】

1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。

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

4. 数据段--存储全局数据和静态数据。

5. 代码段--可执行的代码/只读常量。

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

例:

void Test()
{
	// 1.malloc/calloc/realloc的区别是什么？
	int* p2 = (int*)calloc(4, sizeof(int));
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
	// 这里需要free(p2)吗？
	free(p3);
}

malloc, calloc, 和 realloc 是 C 标准库中的内存分配函数，各自有不同的功能：

malloc(size_t size)：分配一块指定字节数的内存，内容未初始化。返回一个指向该内存的指针。
calloc(size_t num, size_t size)：分配一块内存，能容纳 num 个 size 字节的对象，且所有字节都初始化为零。返回一个指向该内存的指针。
realloc(void* ptr, size_t size)：重新分配之前分配的内存块 ptr 的大小到 size 字节。如果重新分配成功，返回新的内存地址；如果失败，返回 NULL，原始内存块保持不变。

在代码中:

calloc 为 p2 分配了 4 个 int 的内存，并将其初始化为零。然后 realloc 尝试将 p2 重新分配为 10 个 int 的内存。如果 realloc 成功，它将返回一个新的内存地址并将原内存块的内容复制到新的地址。原内存块(p2 指向的内存) 可能会被释放，但如果 realloc 失败，则 p2 仍然有效。

关键点：

如果 realloc 成功：p3 是新的内存地址，原来的内存块 p2 可能已经被释放。在这种情况下，就不需要再对 p2 调用 free。
如果 realloc 失败：p2 仍然有效，你需要释放它。
因此，在这个代码中，只需要调用 free(p3)，无需对 p2 调用 free，因为 p2 的内存已经被 realloc 处理。

面试题:

malloc/calloc/realloc的区别？

1. malloc
全称 : Memory Allocation
函数原型 : void* malloc(size_t size);
功能: 分配一块未初始化的内存块。
参数 : size 是要分配的字节数。
返回值 : 返回一个指向分配内存的指针。如果分配失败，则返回 NULL。
注意 : 分配的内存块中的内容是未初始化的，可能包含垃圾值。

示例:

int* arr = (int*)malloc(10 * sizeof(int));  // 分配 10 个 int 类型的内存

2. calloc
全称 : Contiguous Allocation
函数原型 : void* calloc(size_t num, size_t size);
功能: 分配一块初始化为零的内存块。
参数 : num 是要分配的块数，size 是每块的大小（字节数）。
返回值 : 返回一个指向分配内存的指针。如果分配失败，则返回 NULL。
注意 : 分配的内存块中的所有字节都被初始化为零。

示例:

int* arr = (int*)calloc(10, sizeof(int));  // 分配 10 个 int 类型的内存，并初始化为零

3. realloc
全称 : Reallocation
函数原型 : void* realloc(void* ptr, size_t new_size);
功能: 调整已经分配的内存块的大小。
参数 :
ptr 是指向要调整大小的内存块的指针。
new_size 是新的内存块大小（字节数）。
返回值 : 返回一个指向新分配内存的指针。如果重新分配失败，则返回 NULL，原内存块保持不变。
注意 : 如果 new_size 为零，则行为类似于 free(ptr)，释放内存块。原有的内存块可能会被移动，原指针可能会变得无效。

示例:

int* arr = (int*)malloc(10 * sizeof(int));  // 初始分配 10 个 int 类型的内存
arr = (int*)realloc(arr, 20 * sizeof(int));  // 调整为 20 个 int 类型的内存

参考:

malloc - C++ 参考 (cplusplus.com)

calloc - C++ 参考 (cplusplus.com)

realloc - C++ 参考 (cplusplus.com)

3. C++内存管理方式

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

3.1 new/delete操作内置类型

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

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

3.2 new和delete操作自定义类型

#include<iostream>
#include<stdlib.h>

using namespace std;

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	//内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;
	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;
}

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

4. operator new与operator delete函数

4.1 operator new与operator delete函数

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

operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

/*
 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来释放空间的

/*
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;
}

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

5. new和delete的实现原理

5.1 内置类型

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

5.2 自定义类型

new的原理

1. 调用operator new函数申请空间

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

delete的原理

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

2. 调用operator delete函数释放对象的空间

new T[N]的原理

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

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

delete[]的原理

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

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

6. 定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

使用格式：

new (place_address) type或者new (place_address) type(initializer-list)

place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

例:

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
	}
	cout << "~A():" << this << endl;
private:
	int _a;
};
// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

7. 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在释放空间前会调用析构函数完成空间中资源的清理释放