C++内存管理

RRYc666

已于 2025-04-22 14:20:57 修改

阅读量1k

点赞数 22

CC 4.0 BY-SA版权

文章标签： c++

于 2025-04-22 14:20:23 首次发布

本文链接：https://blog.youkuaiyun.com/Rosillll/article/details/147395586

三、operator new 与 operator delete函数

五、malloc/free和new/delete的区别（面试点）

一、C/C++内存分布

C++的内存可以分成

1、栈区：非静态局部变量/函数参数/返回值等等，栈是向下增长的。

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

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

4、数据段：存储全局数据和静态数据。

5、代码段：可执行的代码/只读常量。

二、C++内存管理方式

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

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

1、new、delete操作内置类型

#include<iostream>
using namespace std;

int main()
{
	//动态申请一个int类型的空间，未初始化
	int* p1 = new int;

	//动态申请一个int类型的空间并初始化为10
	int* p2 = new int(10);

	//动态申请10个int类型的空间，未初始化
	int* ptr1 = new int[10];

	//动态申请10个int类型的空间，并初始化前5个，后面默认为0
	int* ptr2 = new int[10] {1, 2, 3, 4, 5};

	delete p1;
	delete p2;
	delete[] ptr1;
	delete[] ptr2;

	return 0;
}

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

2、new、delete操作自定义类型

#include <iostream>
using namespace std;

struct ListNode
{
	int val;
	ListNode* next;

	ListNode(int x)
		:val(x)
		, next(next)
	{}

	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};

int main()
{
	//new对于自定义类型，调用构造函数
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	ListNode* n4 = new ListNode(4);

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = nullptr;
	
	//delete对于自定义类型,调用析构函数
	delete n1;
	delete n2;
	delete n3;
	delete n4;

	return 0;
}

总结：new/delete和malloc/free最大的区别就是new/delete对于自定义类型除了开空间，还会调用构造函数和析构函数，但内置类型几乎是一样的。

三、operator new 与 operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new和oprator 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来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete最终是通过free来释放空间的。

四、new和delete的实现原理

1、内置类型

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

2、自定义类型

1.new的原理

调用operator new函数申请空间，失败了抛异常。
在申请的空间上执行构造函数，完成对象的初始化。

2、delete的原理

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

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

#include <iostream>
using namespace std;

class A
{
public:
	A(int a, int* ptr)
		:_a(a)
		,_ptr(ptr)
	{}

	~A()
	{
		delete _ptr;
		cout << "~A()" << endl;
	}

private:
	int _a;
	int* _ptr;
};

int main()
{
	A* p1 = new A(1, new int(2));

	//free(p1)不会调用析构函数，导致内存泄漏

	delete p1;//调用析构函数，防止内存泄漏

	return 0;
}