⭐博客主页：️CS semi主页
⭐欢迎关注：点赞收藏+留言
⭐系列专栏：C++初阶
⭐代码仓库：C++初阶
家人们更新不易，你们的点赞和关注对我而言十分重要，友友们麻烦多多点赞＋关注，你们的支持是我创作最大的动力，欢迎友友们私信提问，家人们不要忘记点赞收藏＋关注哦！！！

前言

我们程序中需要存储一些数据，有局部变量、静态变量、全局变量、常量数据和动态申请数据，那么这些数据都存放在哪里呢？接下来我们进行讲解C/C++内存的分布。

一、C/C++内存分布

我们先来画个图，看一下CPU内部的结构图，并且结合前言连个线：

那我们出一道题目供大家练练手：

公布一下答案：CCCAA AAADAB
40 5 4 4OR8 4 4OR8

1、我们先来讲解一下前5个：前三个显而易见是在静态区，因为全局变量和静态数据是一样的，都是存放在静态区的，因为不会被销毁。后两个就是在栈上，因为有自己的栈帧，出了作用域就销毁了。

2、再讲解一下中间6个：

3、再讲一下sizeof那几个值：num1是数组，跟数组个数与类型有关，4*10=40。char2也是算数组大小为5，因为末尾还有个。char2的strlen是4，在截止。pChar3的sizeof是4或者8，因为是指针。而strlen是4。最后一个为4/8因为是指针。

结论：

1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段–存储全局数据和静态数据。
5. 代码段–可执行的代码/只读常量。

二、C和C++内存管理的比较

1、C语言内置类型内存管理

我们在之前的学习中明确了解了C语言的开空间：C语言中动态内存管理方式：malloc/calloc/realloc/free。如下图：

2、C++内置类型内存管理

而我们的C++有自己独有的动态内存管理方式，即：

void TEST()
{
	// new一个
	int* p1 = new int;
	delete p1;

	// new一个数组10个数
	int* p2 = new int[10];
	delete[] p2;

	// new一个进行初始化
	int* p3 = new int(0);
	delete p3;

	// new一个数组并将数组初始化
	int* p4 = new int[10] {1, 2, 3, 4};
	delete[] p4;
}

那有一个问题，为什么要用new，仅仅是因为它比较简洁吗？这其中还是有很深的奥秘的，我们继续。

2、C和C++自定义类型内存管理比较

// 这是C语言的写法
struct ListNode
{
	int _val;
	struct ListNode* _next;
};

struct ListNode* BuyListNode(int x)
{
	struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
	// 检查
	if (newnode == nullptr)
	{
		perror("malloc fail
");
		return;
	}
	// 赋值 
	newnode->_val = 0;
	newnode->_next = nullptr;
	return newnode;
}

int main()
{
	struct ListNode* n1 = BuyListNode(1);
	struct ListNode* n2 = BuyListNode(1);
	struct ListNode* n3 = BuyListNode(1);
	free(n1);
	free(n2);
	free(n3);

	return 0;
}

// 这个是CPP的写法（new和delete都是操作符）
struct ListNode
{
	int _val;
	struct ListNode* _next;

	ListNode(int x)
		:_val(x)
		, _next(nullptr)
	{}
};

int main()
{
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	delete(n1);
	delete(n2);
	delete(n3);

	return 0;
}

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

结论：C++的new对内置类型都差不多，而对于自定义类型方便不少，因为直接new一个赋值和开空间即可，不需要额外再写初始化，直接调用它的构造函数加初始化列表即可。

4、总结

1、对于动态申请的内置类型成员
这两个除了用法上面，malloc和new没有太大的区别。
2、对于动态申请的自定义类型成员
这两个除了用法上面，new和delete可以自动调用它的初始化函数和析构函数，比malloc方便多了。
3、我们规定new和delete匹配，malloc和free匹配，不可乱用。

三、 operator new与operator delete函数

我们来理解一下底层的new和delete：

1、operator new与operator delete函数

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

注意：malloc进行开辟空间如果开辟失败以后返回0，而new开辟空间失败以后会抛异常，这就是我们往后围绕的重点。

为了解我们的这两个函数我们先来了解一个概念，我们利用代码和反汇编来进行一下讲解：
代码如下：

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	int* p3 = (int*)operator new(sizeof(int));
	int* p4 = new int;
	operator delete(p3);
	delete p4;

	A* p1 = (A*)operator new(sizeof(A));
	A* p2 = new A(1);
	operator delete(p1);
	delete p2;

	return 0;
}

new的开空间和构造函数的反汇编：

delete的析构函数和释放空间的反汇编：

所以我们得出结论（new先调用operator new再调用malloc去堆上调用空间，delete先调用operator delete再调用free去释放空间）：

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

我们扒一扒底层的原码：

/*
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)

2、重载operator new与operator delete

注意：一般情况下不需要对 operator new 和 operator delete进行重载，除非在申请和释放空间时候有某些特殊的需求。比如：在使用new和delete申请和释放空间时，打印一些日志信息，可以简单帮助用户来检测是否存在内存泄漏。

// 重载operator delete，在申请空间时：打印在哪个文件、哪个函数、第多少行，申请了多少个
字节
void* operator new(size_t size, const char* fileName, const char* funcName, 
size_t lineNo)
{
 void* p = ::operator new(size);
 cout << fileName << "-" << funcName << "-" << lineNo << "-" << p << "-"
<< size << endl;
 return p;
}
// 重载operator delete，在释放空间时：打印再那个文件、哪个函数、第多少行释放
void operator delete(void* p, const char* fileName, const char* funcName, 
size_t lineNo)
{
 cout << fileName << "-" << funcName << "-" << lineNo << "-" << p <<
endl;
 ::operator delete(p);
}
int main()
{
 // 对重载的operator new 和 operator delete进行调用
 int* p = new(__FILE__, __FUNCTION__, __LINE__) int;
 operator delete(p, __FILE__, __FUNCTION__, __LINE__);
 return 0;
}
// 上述调用显然太麻烦了，可以使用宏对调用进行简化
// 只有在Debug方式下，才调用用户重载的 operator new 和 operator delete
#ifdef _DEBUG
#define new new(__FILE__, __FUNCTION__, __LINE__)
#define delete(p) operator delete(p, __FILE__, __FUNCTION__, __LINE__)
#endif
int main()
{
 int* p = new int;
 delete(p);
 return 0;
}

四、new和delete的实现原理

1、内置类型

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

2、自定义类型

new的原理
1、调用operator new函数申请空间
2、 在申请的空间上执行构造函数，完成对象的构造

delete的原理
1、 在空间上执行析构函数，完成对象中资源的清理工作
2、调用operator delete函数释放对象的空间new T[N]的原理

new T[N]的原理
1、调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请，在申请的空间上执行N次构造函数

delete[]的原理
1、在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2、调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

我们对于自定义类型举个样例：

很妙，先开辟堆上的空间，是利用operator new也就是计算机内部底层代码进行申请空间开辟，再进行构造函数在堆上继续开空间，也就是构造函数，进行自定义函数的初始化。 最后delete的时候是先调用析构函数将空间清理掉，再调用operator delete也就是计算机内部底层的代码进行空间的销毁，实质上就是完成了free的操作。

五、定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
注意：
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

简单而言就是在一些小众的场景下比如频繁申请和调用和释放内存的时候，我们建立一个内存池，提前申请好一大块空间放到内存池中，但需要注意的是这个内存池里面是没有初始化的，所以就需要一个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;
}

六、常见面试题

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

2、 内存泄漏

（1）什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

（2）内存泄漏分类

1、堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

2、系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

（3）如何检测内存泄漏

在vs下，可以使用windows操作系统提供的_CrtDumpMemoryLeaks() 函数进行简单检测，该函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。
因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放。但有些情况下总是防不胜防，简单的可以采用上述方式快速定位下。如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的。

（4）如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智
   能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结

本章大家需要了解什么是new什么是deldete，和我们日常当中认为的这些类型不同，它俩仅仅是操作符，我们看这两个操作符的底层逻辑其实是调用了operator new和operator delete这两个全局函数，然后这两个全局函数的底层又是malloc和free，所以说new和delete绕圈圈到了malloc和free，底层逻辑的实现就是如此，这是我们的重点，最后讲了常见的面试题，大家要注重理解和感受，不可盲目背诵。

家人们不要忘记点赞收藏＋关注哦！！！