c++内存管理（学不会你顺着网线过来找我！）

c/c++内存管理

write in front

作者：@ 不进大厂不改名
专栏：@ 数据结构与算法
作者简介：大一学生 希望能向其他大佬和同学学习！
本篇博客简介：主要介绍了c++中内存管理和c的不同，让我们更深入理解c++中关于内存方面的优化。

1.c/c++中内存的分布

数据结构学了那么久，同学们可能早就忘记内存是如何分布的，就在这里回忆一下吧！

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

回忆完了，我们来练习一下吧！

#include <iostream>
using namespace std;
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";
	const 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. 选择题：
选项 : 1.栈  2.堆  3.数据段(静态区)  4.代码段(常量区)
a.globalVar在哪里？____  b.staticGlobalVar在哪里？____
c.staticVar在哪里？____  d.localVar在哪里？____
e.num1 在哪里？____
f.char2在哪里？____ g.* char2在哪里？___
h.pChar3在哪里？____ i.* pChar3在哪里？____
j.ptr1在哪里？____ k.* ptr1在哪里？____
2. 填空题：
 sizeof(num1) = ____; 
 sizeof(char2) = ____;    strlen(char2) = ____;
 sizeof(pChar3) = ____;   strlen(pChar3) = ____;
 sizeof(ptr1) = ____;
3. sizeof 和 strlen 区别？

通过以上的复习我们应该很容易选出答案了吧！

1. 选择题：
选项 : 1.栈  2.堆  3.数据段(静态区)  4.代码段(常量区)
a.globalVar在哪里？__3__  b.staticGlobalVar在哪里？_3__
c.staticVar在哪里？__3__  d.localVar在哪里？__1__
e.num1 在哪里？__1__
f.char2在哪里？__1__ g.* char2在哪里？_1__
h.pChar3在哪里？__1__ i.* pChar3在哪里？__4__
j.ptr1在哪里？__1__ k.* ptr1在哪里？__2__
2. 填空题：
 sizeof(num1) = __40__; 
 sizeof(char2) = __5__;    strlen(char2) = __4__;
 sizeof(pChar3) = __4__;   strlen(pChar3) = __4__;
 sizeof(ptr1) = __4__;
3. sizeof 和 strlen 区别？
sizeof计算的是占多少字节（空间大小）
strlen计算的是字符串的长度

上面的问题虽然回答了，但是相信同学们还是有问题，我在下面再次解释一遍。

第一题：a和b是全局变量，存储在数据段，c是静态变量存储在数据段。defhj是非静态局部变量存储在栈区，*char2这里需要注意，char2是一个指针，指向首元素，对它进行解引用得到首元素（a）和常量字符串不匹配，于是这个时候会在栈上拷贝一份临时的数据。所以说它在栈区。g是一个常量字符串，所以存储在代码段（常量区），k是动态开辟的空间是在存储在堆区的。
第二题：本题没什么难度就是要记得，sizeof计算字符串的大小时字符串后面的‘\0’也要进行计算，其次在32位操作系统下，指针的大小是4字节
第三题:看详解

2.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开辟的空间会把每个元素都初始化位0。

3.c++中动态内存管理的方式

通过new和delet操作符

c++中可以使用c的内存管理的方式（因为兼容c），但是有些地方也无能为力。因此c++中提出了新的内存管理方式：通过new和delet操作符进行内管理。

void Test()
{
   /动态申请一个int类型的空间
   int* ptr1 = new int;
   /动态申请一个int类型的空间并初始化为10
   int* ptr2 = new int(10);
    动态申请10个int类型的空间
   int* ptr3 = new int[3];
   delete ptr1;
   delete ptr2;
   delete[] ptr3;
}

这里我们进行总结一下：对于申请和释放单个空间我们用new和delete，如果我们要初始化，就在后面加上大括号，里面写我们要初始化的值就可以了。对于申请和释放多个空间时，我们要用new[]和delete[],在c++11中增加了对多个空间的初始化：int *ptr4=new int[2]{0,1};(其实上就是加上大括号和初始化的值)

new和delete操作内置类型（重点）

#include <iostream>
using namespace std;
class A
{
public:
   A(int a = 0)
   	: _a(a)
   {
   	cout << "A():" << this << endl;
   	
   }
   ~A()
   {
   	cout << "~A():" << this << endl;
   }
private:
   int _a;
};
int main()
{
   A* p1 = (A*)malloc(sizeof(A));
   A* p2 = new A(1);
   free(p1);
   delete p2;
   // 内置类型是几乎是一样的
   int* p3 = (int*)malloc(sizeof(int)); // C
   int* p4 = new int;
   free(p3);
   delete p4;
   A* p5 = (A*)malloc(sizeof(A) * 10);
   A* p6 = new A[10];
   free(p5);
   delete[] p6;
   return 0;
}

我们可以看到在申请和释放空间时，new会自动调用构造函数，而delete会自定调用析构函数，而malloc和free不会。这也就是为什么在c++中用new和delete的原因，这样确实方便很多，在申请（new）了一块空间后就初始化了，比malloc方便了不少。

这里可以看到p2初始化了，但是p1没有初始化（这样可以印证上面new调用了构造函数，进行了初始化，而malloc却没有初始化）

c和c++报错误的区别（也就是面向过程和面向对象报错的区别）（重点）

面向过程的语言的错误是通过错误码来识别的（c语言）
面向对象的语言的错误是通过抛出异常识别的（c++语言）

c语言中mallloc失败的报错是：

int* a = (int*)malloc(sizeof(int) * 4);
   if (a == NULL)
   {
   	perror("malloc fail");
   	exit(-1);
   }

c++语言中mallloc失败的报错是：（代码看一下就行，你没有必要掌握）

int main()
{
   try
   {
   while (1)
   {
   	new char[1024u*1024u*1024u];
   	cout << "success" << endl;
   }
   cout << "test" << endl;
   }
   catch (exception& e)
   {
   	cout << e.what() << endl;
   }
   
   return 0;
}

这里我们可以发现：
1.new空间失败后会直接抛出一个异常到catch捕获。
2.new空间失败后后面的语句不会执行。

#include <iostream>
#include <iostream>
using namespace std;
int main()
{
    try
    {

        new char[1024u * 1024u * 1024u];
        cout << "success" << endl;
        cout << "test" << endl;
        new char[1024u * 1024u * 1024u];
        cout << "开辟成功！" << endl;
    }
    catch (exception& e)
    {
        cout << e.what() << endl;
    }

    return 0;
}

这里证明了上面的两点（1.空间开辟失败后不会执行下面的语句，2.并且会抛出异常到catch捕获）

类型不匹配会遇到问题

1.如果我们使用了new，销毁就要用delete
2.如果我们使用了new[]，销毁就要用delete[]
3.如果我们使用了malloc,realloc,calloc销毁就要用free

这个一定按照规定来（不能随意使用）

4.operator new和operator delete函数（重点）

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

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

为了更好地理解operatpr new和 operator free,我在下面画了一张图。（以便于更好地理解）

总结：通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

5. new和delete的实现原理

内置类型

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

new的原理

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

delete的原理

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

new[N]的原理

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

delete[]的原理

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

这里需要注意：new和delete的区别
new是先开辟空间再调用构造函数
delete是先调用析构函数再销毁空间

6. 定位new表达式（placement-new）

定位new表达式是指在已经分配初始化的原始内存空间中调用构造函数初始化一个对象
它的使用格式：
new(place_address) type(无参数)
或者：
new(place_address)type(intitializer-list)
place_address必须是一个指针，intitializer-list是类型的初始化列表。

class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
A* p1 = (A*)malloc(sizeof(A));
//new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
return 0;
}

这是没有使用定位new表达式的效果，创建的变量确实没有初始化。

当我们使用了定位new表达式后（此时的确是对创建的变量进行了初始化）

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

8.内存泄漏（这里先简单了解一下）

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

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

这里演示一下:(使用下面的代码)

while (1)
	{
		int* p = new int[3000];
		cout << p << endl;
	}

内存泄漏的分类（了解一下就行）

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

如何避免内存泄漏

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

省流：内存泄漏很常见，要么提前预防（使用智能指针），要么事后查错（使用泄漏检测工具）