C++内存管理

C++内存分布

首先给大家看一段代码，并且后面附上其变量所在的内存空间

大家可以先不看其分布，自己判断其在哪个内存区，之后再看是否对错

【说明】

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

现在我们给出大家两个问题，1.为什么要分这些内存区域 2.哪些区是我们需要重点关注的

第一个问题的答案很简单，因为方便管理，所有类型的变量放在一个区域，想要管理是极其困难的；而分出几个区域的话，我们就能一个区域干一个区域的事。
第二个问题：我们选择的是堆，原因在于：堆是留给用户控制的，而其他的变量编译器会自己处理

这里我们再给大家一些选择题和填空题看看

1. 选择题：
   选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
   globalVar在哪里？____ staticGlobalVar在哪里？____
   staticVar在哪里？____ localVar在哪里？____
   num1 在哪里？____

   char2在哪里？____ *char2在哪里？___
   pChar3在哪里？____ *pChar3在哪里？____
   ptr1在哪里？____ *ptr1在哪里？____

2. 填空题：
   sizeof(num1) = ____;
   sizeof(char2) = ____; strlen(char2) = ____;
   sizeof(pChar3) = ____; strlen(pChar3) = ____;
   sizeof(ptr1) = ____;

3. sizeof 和 strlen 区别？

选择题上端的正确答案是 栈 栈 栈 代码段 栈 堆
分析:
globalVar全局变量在数据段（定义在全局） staticGlobalVar静态全局变量在静态区（static关键字）
staticVar静态局部变量在静态区 localVar局部变量在栈区
num1局部变量在栈区

char2在哪里？A *char2在哪里？A
pChar3在哪里？A *pChar3在哪里？D
ptr1在哪里？A * ptr1在哪里？B
分析:
char2局部变量在栈区
char2是一个数组，把后面常量串拷贝过来到数组中，数组在栈上，所以 * char2在栈上
pChar3局部变量在栈区 *pChar3得到的是字符串常量字符在代码段
ptr1局部变量在栈区 *ptr1得到的是动态申请空间的数据在堆区

2. 填空题：
   sizeof(num1) = 40;//数组大小,10个整形数据一共40字节
   sizeof(char2) = 5;//包括\0的空间
   strlen(char2) = 4;//不包括\0的长度
   sizeof(pChar3) = 4;//pChar3为指针
   strlen(pChar3) = 4;//字符串“abcd”的长度，不包括\0的长度
   sizeof(ptr1) = 4;//ptr1是指针

3.sizeof判断的是内存大小，strlen一般用于判断字符数组的长度

1. sizeof
   功能：sizeof 是一个运算符，用于获取特定类型或对象在内存中所占用的字节数。
   操作对象：它可以作用于变量、数据类型、结构体/联合体等。
   返回值：返回的是一个 size_t 类型的无符号整数，表示字节数。
   编译时确定：sizeof 的值在编译时就已经确定，因为它只是简单地返回类型或对象在内存中的大小。
2. strlen
   功能：strlen 是一个函数，用于获取以 \0（空字符）结尾的字符串的长度（不包括 \0）。
   操作对象：它只能作用于 C 风格的字符串（即字符数组，且以 \0 结尾）。
   返回值：返回的是一个 size_t 类型的无符号整数，表示字符串的长度（不包括空字符）。
   运行时确定：strlen 的值在运行时确定，因为它需要遍历字符串直到找到 \0。

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

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

首先回答第一个问题，malloc、calloc、realloc的区别是什么？众所周知，这三个用于C语言动态内存管理的符号都是函数，而其中的区别在于：
1.malloc：只是申请n个字节的空间，不会初始化
2.calloc：申请n*m个字节的空间，会全部初始化为0
3.realloc：申请扩容p指针指向的空间大小，扩容后大小为n，可能会原地扩容，也可能会异地扩容。异地扩容会自动释放原来的空间，并在另一个地址处申请n个空间，并且返回另一个地址的指针

C++内存管理方式

我们很熟悉C语言的内存开辟和释放，那C++又是怎样进行这些动作的呢？
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

new/delete操作内置类型

	//注意new和delete都是操作符，而非函数
	int* ptr = new int;//动态申请一个int类型的空间
	int* ptr2 = new int(10);//动态申请一个int类型的空间并初始化为10
	int* ptr3 = new int[4];//动态申请4个int类型的空间
	int* ptr4 = new int[5] {1, 2};//动态申请5个int类型的空间，初始化前两个元素为1，2
	//后三个元素均初始化为0

	delete ptr;//释放
	delete ptr2;
	delete[] ptr3;
	delete[] ptr4;

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

不匹配的情况在内置类型中体现不大，在自定义类型中表示明显，后面会给大家演示

new和delete操作自定义类型

这是我们用两种方式创建一个A类对象的过程，我们会发现，在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。
并且new在失败之后还会抛出异常，不需要我们手动检查，但这里我们还没有学到抛异常这个部分，所以我们之后再说

我们会发现，其实new和delete都是为了自定义类型而创建的，如果用C语言的内存管理会很麻烦

operator new和operator delete函数

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

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

new和delete的实现原理

内置类型

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

自定义类型

new的原理

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

delete的原理

3. 在空间上执行析构函数，完成对象中资源的清理工作
4. 调用operator delete函数释放对象的空间
   eg.这个顺序是因为，如果我们先执行operator delete的话，我们就无法清除对象资源的清理工作了，因为找不到对象原来的位置

new T[N]的原理

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

delete[]的原理

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

就像上图所示

这里给大家看一段代码，提出一个问题：

我们从反汇编能看出，我们在创建10个A类对象时，开辟了58h个字节的空间，也就是8+5*16=88个字节的空间，但是明明我们只需要10 * 8=80个字节的空间，这是为什么呢？我们再看内置类型开辟时的空间，与其对比分析一下：

很明显，这里是28h，也就是8+32=40，也就是40个字节的空间，这好像就没有任何问题，这是为什么呢？

我们转到ptr的内存地址，我们会发现，在ptr的地址前，还有0a 00 00 00 00 00 00 00这一串，而用16进制计算会恰好发现，0a就是10的意思，而刚好我们创建了10个A类对象，所以这是巧合吗？显然不是。是因为我们就是把创建对象的个数存储在了ptr之前，而这是为了在使用delete[]的时候可以知道需要调用几次析构函数。而这在底层是由operator[]做的

注意：如果用内置变量，就不需要，因为其不需要调析构函数，这也是为什么我们刚才发现int * ptr创建的内存空间只有40个字节的原因

针对这个，还有一些其他的有趣现象，那就是如果我们不显式定义析构函数，我们会发现其又变成了40，其原因是因为编译器知道自己的析构函数啥也不干，所以直接给优化掉了

而当我们使用int * ptr创建十个int型空间之后，我们使用delete ptr是不会报错的，因为其并不是只释放一个int大小的空间；但是如果是A * ptr，那就错了，因为只调了一次析构函数，当我们运行时，delete将会报错，但同样的，跟之前一样，如果没有显式析构，我们仍然不会出问题。

delete报错的原因是因为释放位置错了，我们delete是从ptr指向的那个头开始free的，但是我们是从储存对象个数的那个位置开始malloc的，不能进行部分free，而delete[]是会向前偏移八个字节（或者四个字节，看是在32位还是64位系统下）再进行free，而如果没有多开那四个字节，那就不会有问题。所以这里也是之前我们说必须要匹配使用的问题，不匹配结果是不确定的

定位new表达式(placement-new) （了解）

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

	A* ptr = (A*)malloc(sizeof(A));
	new(ptr)A;
	ptr->~A();
	free(ptr);

	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	free(p2);

给大家看一个例子，这里我们就是使用了定位new表达式，毕竟在这两个开辟空间时我们都没有对其调用构造函数，而且在构造p2的时候还进行了传参，现实当中不会这么用 没必要

如果内存是从内存池（也是系统开的）开出来的，那就只有内存没有值，一般都是直接从系统要，就是提前储备 会快一点。

常见面试题

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

内存泄漏

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

内存泄漏分类（了解）

C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何检测内存泄漏（了解）

在vs下，可以使用windows操作系统提供的_CrtDumpMemoryLeaks() 函数进行简单检测，该函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。