这一节学完，我们 C嘎嘎就算是正式入门了，但是之后的课还会更上一阶d(ŐдŐ๑) 继续坚持！

【本节目标】

1. C/C++内存分布

2. C语言中动态内存管理方式

3. C++中动态内存管理

4. operator new与operator delete函数

5. new和delete的实现原理

6.常见问题

【本节目标】

1. C/C++的内存分布

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

1）malloc

2）calloc

3）realloc

4）free

3.C++内存管理方式

3.1new和delete的基本操作

3.2new和delete操作符自定义类型

3.3总结：

4.operator new与operator delete函数

5.new和delete的实现原理

5.1内置类型

5.2自定义类型

6.常见问题：

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

2）内存泄漏

3）内存泄漏分类

4）如何避免内存泄漏

我们都知道在 C语言 中，可以使用 malloc、realloc、calloc 来开辟空间，使用 free 来销毁空间

那我们 C++ 应该怎样去申请空间呢？

1. C/C++的内存分布

对于内存，我们的操作系统有自己的一个划分，划分为六个空间，分别是：内核空间、栈、内存映射段、堆、数据段、代码段

我们先来看一段代码：

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";
	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);
}

答案和解释：

1.选择题

globalVar 存储于 数据段

staticGlobalVar 存储于 数据段

staticVar 存储于 数据段

localVar 存储于栈

localVar1 存储于栈

num1 存储于栈

char2 存储于栈

因为 char2 是一个数组，存在栈上面的，而 “abcd” 是存在常量区的常量，只是拷贝给了 char2

*char2 存储于栈

数组名就是首元素的地址，也就是 char 是地址，*char2 相当于对 cahr2 进行解引用，找到它的内容，那么它的内容是存储在栈上面的

pChar3 存储于栈

pChar3 是一个指针变量，这个指针变量是在栈上面开的

*pChar3 存储于 代码段

pChar3 是一个指针变量，它存的是一个地址，它指向常量区的字符串 “a b c d”，*pChar 就是对这个指针变量解引用，找到了它的内容，也就是 “abcd” ，所以它是存在代码段的

ptr1 存储于栈

*ptr1 存储于堆

2.填空题

注意：sizeof 是求字节大小，strlen 是求字符串长度的。

sizeof(num1) = 40（算对象占用空间的大小）

sizeof(char2) = 5（char2 是一个字符数组，求大小要计算 ‘\0’）

sizeof(pChar3) = 4/8 （指针在 32 位平台大小是 4，64 位平台大小是 8）

sizeof(ptr1) = 4/8

strlen(char2) = 4（char2 是一个字符数组，求长度不计算 \0）

strlen(pChar3) = 4

其内存分布图如下：

说明：

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

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

1）malloc

malloc 函数的功能是开辟指定字节大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个 NULL（空指针）。

它使用的时候，传参只需传入需要开辟的字节个数。

2）calloc

calloc 函数的功能也是开辟指定大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个 NULL（空指针）。

calloc 函数传参时需要传入开辟的内存用于存放的元素个数和每个元素的大小。

calloc 函数开辟好内存后会将空间内容中的每一个字节都初始化为 0。

3）realloc

realloc 函数可以调整已经开辟好的动态内存的大小，
第一个参数是需要调整大小的动态内存的首地址，第二个参数是动态内存调整后的新大小。

如果第一次使用realloc时检测到首地址未开空间，则realloc和malloc的功能一致

注意：

原地扩。需扩展的空间后方有足够的空间可供扩展，此时，realloc 函数直接在原空间后方进行扩展，并返回该内存空间首地址（即原来的首地址）。
异地扩。需扩展的空间后方没有足够的空间可供扩展，此时，realloc 函数会在堆区中重新找一块满足要求的内存空间，把原空间内的数据拷贝到新空间中，并主动将原空间内存释放（即还给操作系统），返回新内存空间的首地址。
扩容失败。需扩展的空间后方没有足够的空间可供扩展，并且堆区中也没有符合需要开辟的内存大小的空间。结果就是开辟内存失败，返回一个 NULL（空指针）。

4）free

free 函数的作用就是将 malloc、calloc 以及 realloc 函数申请的动态内存空间释放，其释放空间的大小取决于之前申请的内存空间的大小。

3.C++内存管理方式

C 语言内存管理方式在 C++ 中可以继续使用但C++有更简单的用法：

通过 new 和 delete 操作符进行动态内存管理。

3.1new和delete的基本操作

（1）new 一个 int 类型的对象

int main()
{
	// 用malloc动态申请一个int类型的空间
	int* p1 = (int*)malloc(sizeof(int));
	// 销毁p1
	free(p1);


	// 动态申请一个int类型的空间
	int* p1 = new int;
	// 销毁p1
	delete p1;

	return 0;
}

（2）new 10 个 int 类型的对象

int main()
{
	// 用malloc动态申请一个int类型的空间
	int* p2 = (int*)malloc(10 * sizeof(int));
	// 销毁
	free(p2);


	// 动态申请一个int类型的空间
	int* p2 = new int[10];
	// 销毁
	delete[] p2;

	return 0;
}

delete[ ] 对应的是new[ ] ，是申请多个空间时的样子。

（3）new 一个 int 类型对象，然后初始化为 10

{
	int* p3 = (int*)malloc(sizeof(int));
	*p3 = 10; //赋值
	//销毁
	free(p3);


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

	return 0;
}

（4）new 10 个 int 类型对象，并进行初始化

int main()
{
	//动态申请10个int类型的空间并初始化为1到10
	int* p8 = (int*)malloc(sizeof(int) * 10); //申请
	for (int i = 0; i < 10; i++) //赋值
	{
		p8[i] = i;
	}
	free(p8); //销毁

	//动态申请10个int类型的空间并初始化为1到10
	int* p4 = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//销毁p4
	delete[] p4;

	return 0;
}

当然如用new在赋值的时候，如果只给前面的控件赋值，后面的空间会赋值为0

总结如下图：

申请和释放单个元素的空间，使用 new 和 delete
申请和释放连续的空间，使用 new[ ] 和 delete[ ]

3.2new和delete操作符自定义类型

对于内置类型来说，malloc 和 new 用法几乎一样，
但是对于自定义类型来说，new和delete相比于malloc，会调用构造函数和析构函数

这里以链表为列，看看malloc和new的区别

malloc：

//链表
struct ListNode
{
    ListNode* next;
    int val;
};

//申请节点
struct ListNode* BuyListNode(int x) 
{
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(node);

    node->next = NULL;
    node->val = x;
    return node;
}

int main()
{
    // 定义n1节点
    struct ListNode* n1 = BuyListNode(1);
    free(n1);
    return 0;
}

new：

//链表
class ListNode
{
public:
    //构造函数
    ListNode(int val = 0)
        :_next(nullptr), _val(val) // 初始化列表
    {
        cout << "ListNode" << endl;
    }
    ~ListNode()
    {
        cout << "~ListNode" << endl;

    }
private:
    ListNode* _next;
    int _val;
};

int main()
{
    // 定义n1节点
    ListNode* n2 = new ListNode(2); // new会去调用ListNode的构造函数
    delete n2;

    return 0;
}

3.3总结：

1）malloc/free是函数，而new/delete是关键字
2）C++ 中如果是申请内置类型的对象或是数组，用 new/delete 和 malloc/free 没有什么区别。
3）如果是自定义类型的话，new 和 delete 分别是开空间+构造函数、析构函数+释放空间，而 malloc 和 free 仅仅是开空间和释放空间，可以看到区别还是很大的。
4）建议在 C++ 中无论是内置类型还是自定义类型的申请和释放，尽量都使用 new 和 delete。

4.operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数

new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

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自定义类型

1）new的原理

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

2）delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作
2. 调用operator delete函数释放对象的空间

3）new T[N] 的原理

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

4）delete[ ] 的原理

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

6.常见问题：

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）内存泄漏

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

什么是内存泄漏：

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

内存泄漏的危害：

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

3）内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。

假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生堆内存泄漏(Heap leak)