目录

一、C/C++ 内存分布

二、C语言动态内存管理方式

三、C++使用new和delete 的原因

四、C++动态内存管理方式

         1.new和delete

2.operator new和operator delete

五、内存泄漏

---

一、C/C++ 内存分布

C/C++内存被分为6个区域：

（1）内核空间存放内核代码和环境变量

（2） 栈（也叫堆栈）存放非静态局部变量/函数参数/返回值等等，栈是向下增长的。

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

（4）堆用于程序运行时动态内存分配，堆是向上增长的。

（5）数据段存储全局数据和静态数据。

（6）代码段存放可执行的代码/只读常量。

如下图所示：

二、C语言动态内存管理方式

C语言动态内存管理malloc、calloc、realloc、free的详细介绍请参考文章C语言-动态内存管理详解

三、C++使用new和delete 的原因

new和delete是C++向内存申请空间和释放空间的操作符， C++为什么要使用new和delete？

1.C语言使用malloc、calloc、realloc、free管理的不便之处在于：

（1）手动申请内存需要手动计算字节数的大小

（2）对返回值类型void *要进行强转，否则无法解引用

（3）内存是否申请成功需要对返回值进行判空

（4）需要include头文件<stdlib.h>

2.new和delete的使用对自定义类型会进行处理：

（1）new会调用构造函数对类对象进行初始化

（2）delete会调用析构函数进行资源清理

四、C++动态内存管理方式

  1.new和delete

 （1）new/delete和malloc/free对内置类型的操作没有区别：

①申请和释放单个空间，使用new和delete

②申请和释放连续空间，使用new[ ]和delete[ ]

#include<stdlib.h>
int main()
{
	//操作内置类型

	//1.申请单个int对象
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);

	int* p2 = new int;//int* p2 = new int(10); 申请单个int对象并将其初始化为10
	delete p2;
	
	//2.申请10个元素的int数组
	int* p3 = (int*)malloc(sizeof(int) * 10);
	free(p3);

	int* p4 = new int[10];
	delete[] p4;//自定义类型数组delete要带上[]，否则不匹配，程序会意外终止
	
	return 0;
}

C++11支持用{}对数组初始化：

int* p5 = new int[5]{1,2,3,4,5};
delete[] p5;

 （2）new/delete和malloc/free对自定义类型的操作有区别：

①malloc/free对自定义类型的操作只会开空间/释放空间

②new操作自定义类型会开空间+初始化，delete操作自定义类型会调用析构函数清理+释放空间

#include<iostream>
#include<stdlib.h>
using namespace std;

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _val;

	ListNode(int val = 0)
		: _next(nullptr)
		, _prev(nullptr)
		, _val(val)
	{
		cout << "this.val =" << val << endl;
	}

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

int main()
{
	struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	struct ListNode* n2 = new ListNode;

	free(n1);
	delete n2;

	return 0;
}

F10监视，走完28行执行了new操作，发现n1 malloc的3个成员变量是随机值，而n2 new的3个成员变量都被初始化了，所以new不仅会开空间，还会调用自定义类型的构造函数进行初始化： 

 走完31行，执行了delete操作，发现打印了析构函数的内容，调用了析构函数：

 因此，C++不仅开空间还初始化，不仅释放空间还清理资源。

总结：

（1）C++如果为内置类型申请空间，malloc和new没有区别

（2） C++如果为自定义类型申请空间，区别很大：

          ①new和是开空间+初始化，delete是析构清理+释放空间

          ②malloc仅仅是开空间，free仅仅是释放空间

建议：C++中，无论是内置类型，还是自定义类型的申请释放，尽量使用new和delete

如何在堆上申请4GB的空间？在32位机器上执行下面代码，程序会崩溃，因为2^32=1024*1024*1024*4，32位机器一共才4G，根据C++内存分布，内核空间占1G，剩余的5个区域一共占3G，因此32位平台是申请不到4GB内存空间的。

void* p1 = malloc(1024 * 1024 * 1024 * 4);
cout << p1 << endl;

但是，在VS上将项目-项目属性-配置管理器-选择x64平台：

 这时64位机器共2^64，大概160亿GB左右，远远大于4G，顺利申请到了4G空间，但这4G其实也是虚拟的：

2.operator new和operator delete

定义：operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间，它们不是new和delete的重载。

与malloc区别：operator new、operator delete的用法和malloc、free的用法是一样的，功能都是在堆上申请释放空间，但是失败了的处理方式不一样，malloc失败返回NULL，operator new失败以后抛异常。

使用new为自定义类型ListNode申请空间并初始化：new会调用operator new函数和构造函数，operator new会调用malloc和失败抛异常机制，因此new和operator new申请失败都会抛异常：

从上图可以看出，new并不直接调用 malloc，而是调用了operator new，因为operator new被封装了，malloc申请失败直接报返回值，但operator new申请失败会抛异常。

delete先析构把资源清理掉，再调用operator delete释放栈空间本身。

在32位系统中申请0x7fffffff字节大小的空间，operator new函数申请空间失败抛异常：

void f()
{
	void* p3 = malloc(0x7fffffff);
	if (p3 == NULL)
	{
		cout << "malloc fail " << endl;
	}

	void* p4 = operator new(0x7fffffff);
    cout << "申请空间ing" << endl;

    char* p5 = new char('C');
	char* p6 = new char[2];

    ListNode* p7 = new ListNode[5]{1,2,3,4,5};
}

int main()
{
	
	try
	{
		f();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

 申请空间失败：没有打印申请空间ing，说明抛异常会直接跳到catch的位置，就不会执行cout << "申请空间ing" << endl;

F10-调试-反汇编，对于内置类型，发现new调的是operator new，new 类型[ ] 其实调的就是operator new[ ]:

 对于自定义类型，会调operator new 和ListNode构造函数

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

五、内存泄漏

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

危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会 导致响应越来越慢，最终卡死。

假如申请了堆内存，但是忘记释放，会造成内存泄漏，但只是指针丢失，而不是内存丢失：

int main()
{
	int *p1 = (int *)malloc(sizeof(int));

	return 0;
}

为什么内存不会丢？

因为在堆上申请了一块空间后，拿到了指向这块空间的指针，现在就可以访问这块空间了。但是访问之后由于疏忽或者程序设计错误，没有了这块指针，或者不用了这块指针，但并不知道指针没释放。而内存始终存在，把空间分配使用者的意思是，这块空间的使用权交给了使用者，free就是把这块内存空间还给了操作系统，现在系统就可以把这块空间再重新分配给别的使用者，因此如果不归还内存，内存会越来越少，直到最后无法正常使用。

普通程序就算内存泄漏，问题也不大，因为程序运行的是进程，每个进程都有自己的运行空间，它们一起映射物理地址，进程只要正常结束，就算有内存泄漏，最后也会被释放掉。