C++动态内存管理

void Test()
{
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);

	// 1.malloc/calloc/realloc的区别是什么？
	int* p2 = (int*)calloc(4, sizeof (int));
	int* p3 = (int*)realloc(p2, sizeof(int)* 10);

	// 这里需要free(p2)吗？
	free(p3);
}

int main()
{
	Test();
	_CrtDumpMemoryLeaks();
	return 0;
}

我们通过调用_CrtDumpMemoryLeaks();函数，这是一个操作系统定义的函数，用来查看有无内存泄露的，发现，即使calloc的空间没有free也不会有内存泄漏，而相反的malloc和realloc申请的空间如果不释放就会有内存泄漏，这是为什么呢？这就涉及到它们之间的区别了。

问：malloc/calloc/realloc的区别？

首先，这三者都是函数，使用之前都需要包含相应的头文件（stdlib.h）。

这三者具体的函数以及参数返回值作用等等都在之前的一篇文章动态内存管理（堆区）中说的很细：

CSDNz

这里主要谈谈他们的区别：

1.函数名字不同和参数类型不同。
2.calloc会对申请空间(按字节)初始化，并且初始化为0，而其他两个不会。
3.malloc申请的空间必须使用memset初始化
4.realloc是对已经存在的空间进行调整，当第一个参数传入NULL的时候和malloc一样

那么calloc申请的空间没有释放到底会有内存泄漏的风险吗？

三、C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但是在某些情况下使用起来会比较麻烦，因此C++提出了自己的内存管理方式：通过new和delet操作符进行动态内存管理。

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[]

2.new和delete操作自定义类型

class Test
{
public:
	Test()
		: _data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}

private:
	int _data;
};

我们都知道创建一个类类型对象的时候系统会自动帮我们调用他的构造函数并进行初始化那么

对于上面这个类，我们分别使用malloc/free，new/delet“申请对象”来进行测试一下：

先使用malloc和free：

再使用new试试：调用了构造函数

使用free：调用了析构函数

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

3.new和delet以及new T[N]和delete [ ] T 以及的实现原理

我们知道了用new创建对象时会调用拷贝构造函数，使用delet释放对象的时候会调用析构函数，那么他们底层是怎么实现的呢？

我们利用如下代码进行测试：

class Date
{
public:
	Date()
		: _data(0)
	{
		cout << "Date():" << this << endl;
	}
	~Date()
	{
		cout << "~Date():" << this << endl;
	}

private:
	int _data;
};

void Test()
{
	// 申请单个Test类型的对象
	Date* d1 = new Date;

	// 申请10个Test类型的对象
	Date* d2 = new Date[10];

	delete d1;
	delete[] d2;
}

int main()
{
	Test();
	return 0;
}

我们通过查看反汇编发现用new创建一个对象的时候经历了下面两步：

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

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

我们再通过反汇编查看delet一个对象的时候也分别经历了下面两步：

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

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

我们通过new和delet单个对象我们不难得出N个成员的原理：

new T[N]的原理：

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

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

delete[]的原理：

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

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

4.operator new与operator delete的类专属重载(了解)

我们通过反汇编已经知道了new 在底层调用 operator new 全局函数来申请空间， delete 在底层通过 operator delete 全局函数来释放空间。

那么现在我们来看看这两个函数

operator new函数：

/*
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函数：

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

5.new操作符，操作符new和placement-new三者的区分

（1）new操作符----->用来申请空间的new关键字 T*pt = new T；

（2）操作符new，delete------>一个函数，比如：void* operator new(size_t size);void* operator delet(size_t size);

注意：该函数是可以重载的，一般情况下不需要重载---直接库提供的就行，除非有特殊的需求----比如：申请空间时顺便打印日志信息---帮助定位内存泄漏

（3） placement-new

6.常见的一些面试题：

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

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

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

2.内存泄漏

什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会

导致响应越来越慢，最终卡死

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 2.异常安全问题
	int* p3 = new int[10];

	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.

	delete[] p3;
}

内存泄漏分类

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过 malloc / calloc / realloc / new 等从堆中分配的一块内存，

用完后必须通过调用相应的 free 或者 delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那

么以后这部分空间将无法再被使用，就会产生 Heap Leak 。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统

资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。 ps ：这个理想状

态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保

证。

2. 采用 RAII 思想或者智能指针来管理资源。

3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

4. 出问题了使用内存泄漏工具检测。 ps ：不过很多工具都不够靠谱，或者收费昂贵。

总结一下 :

内存泄漏非常常见，解决方案分为两种： 1 、事前预防型。如智能指针等。 2 、事后查错型。如泄漏检测工

具。