【C++修理之路】内存管理

内存管理是什么？

内存管理是每个C++程序员最令人深恶痛绝的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET（.NET是开放源代码，托管于GitHub），他们的内存管理基本是自动的，当然你也放弃了自由和对内存的支配权，还放弃了C++超绝的性能，我选择 C++这门语言主要就是它强大的性能，听别人说：你想学好编程最好是从C入门把底层逻辑搞清楚，毕竟“c生万物嘛！”，但你想成为超级大佬，就把C++学好吧，虽然学习的过程中是很痛苦的，但是有一天你会发现用起来非常“爽！”。

内存的分配

在C++中，内存分成5个区，他们分别是堆区、栈区、自由存储区、全局/静态存储区和常量存储区，有人会问：为什么要这样划分呢？因为这是根据我们程序的需求来划分的。
栈区：就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。

堆区：操作系统层面的术语。就是那些由malloc等分配的内存块，用free来结束自己的生命的。

自由存储区：C++层面上的术语，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。new的申请是调用的malloc，自由存储区就和堆类似，但不等价，可参考该文章C++ 自由存储区是否等价于堆？

全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改
请看下图，大家就一目了然了：

推荐大家看一本书《深入理解计算机系统》，虚拟存储器这一个章节讲的很详细，有兴趣的小伙伴可以看看。
我们不妨来做两个练习深入了解一下，请看图一解析：

1.选C，第一个是全局变量，所以在静态区
2.选C，第二个是静态变量，它也在静态区
3.选C，第三个它虽然在局部变量，但也在静态区
4.选A,局部变量，栈区
5.选A,局部变量，栈区
6.选A,它是数组，所以在栈区
7.把数组里面常量字符串内容拷贝在数组里面，数组名又表示的是整个数组，解引用后代表的是首元素的地址，所以还是在栈区
8.选A,局部变量，const修饰的常变量还是在栈区
9.选D，它是一个指针，指针存的是常量字符串的地址，常量字符串又在代码段,代码段在常量区
10.选A，首先它是一个局部的指针，然后在堆上申请了16个字节的空间，16个字节的地址在堆上，所以它还是在栈上
11.选B，它在堆上，因为是在堆申请的空间，最后返回它所指向的地址空间
图二解析：

1.数组名表示整个数组的大小，大小是40
2.是一个数组包含一个’/0’，大小是5
3.strlen没有’/0’,大小就是4
4.它是一个指针，大小是4/8
5.strlen遇到’/0’就结束，大小是4
6.它是一个指针，指针它就是一个地址编号，所以大小是4/8

new的初始化

1.初始化一个值

我们可以看到p2已经new被初始化了，但是delete了以后就被清理了，这个空间里的值就是一个随机值了。

2.初始化多个值

我们可以看到前5个数值都已经被初始化了，后面的会被默认初始化为0。

new和delete的用法

一.new的功能如下:
1.在堆上分配空间
2.在分配的空间上调用对象的构造函数
（这也是 new 和 malloc的主要区别，是否调用构造函数）
二. delete的功能如下：

1. 首先调用 这个对象 的析构函数
2. 然后释放这个对象的空间

#include
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* p3 = new A[10];	
	delete[] p3;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

编译器要知道它调用了多少次析构函数，因此new申请空间的时候会多开4个字节的空间来知道它要调用多少次，这个空间存放它的调用个数delete释放p3的时候，编译器会-4字节，把这个10取出来就知道调用个数了delete释放的是一个对象不是多个对象，释放的位置从存放个数空间的位置开始释放，因此就会报错

怎么解决？
不显示写，编译器认为是自己生成的，调不调用都无所谓，也就不会释放，释放的位置也就不会发生偏移就不报错，所以这块资源就不需要清理

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

malloc/free和new/delete的区别

#include
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()
{
 // new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
还会调用构造函数和析构函数
 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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

try catch的用法

在c++中，可以直接抛出异常之后自己进行捕捉处理，这样就可以在任何自己得到不想要的结果的时候进行中断，比如在进行数据库事务操作的时候，如果某一个语句返回SQL_ERROR则直接抛出异常，在catch块中进行事务回滚

#define _CRT_SECURE_NO_WARNINGS 
#include
using namespace std;
int main()

{
	try
	{
	while (1)
	{
		//int* p1 = (int*)malloc(1024*1024);
		//new失败，抛异常，不是打印空指针
		char* p1 = new char[1024 *1024*1024];

		if (p1)
		{
			cout << (void*)p1 << endl;
		}
//cout是自动识别类型,char*会当成%s也就是字符串去打印,遇到‘/0’
//会终止，而上面空间没有初始化是随机值，打印的都是乱码，因此要强制类型转换
		else
		{
			cout << "申请失败" << endl;
			break;
		}
	}
}
//内存申请失败就跳到catch的位置被捕获
catch (exception& e)
		{
			cout << e.what() << endl;
		}
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

内存泄漏

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

void MemoryLeaks()
{
   // 1.内存申请了忘记释放
  int* p1 = (int*)malloc(sizeof(int));
  int* p2 = new int;
  
  // 2.异常安全问题
  int* p3 = new int[10];
  
  Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
  
  delete[] p3;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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

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

int main()
{
 int* p = new int[10];
 // 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏
 _CrtDumpMemoryLeaks();
 return 0;
}

// 程序退出后，在输出窗口中可以检测到泄漏了多少字节，但是没有具体的位置
Detected memory leaks!
Dumping objects ->
{79} normal block at 0x00EC5FB8, 40 bytes long.
Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.
1
2
3
4
5
6
7
8
9
10
11
12
13
14

因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放。但有些情况下总是防不胜防，简单的可以采用上述方式快速定位下。如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的。

1. 在linux下内存泄漏检测：linux下几款内存泄漏检测工具
2. 在windows下使用第三方工具：VLD工具说明
3. 其他工具：内存泄漏工具比较

内存泄漏分类（了解）

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

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
   总结一下:
   内存泄漏非常常见，解决方案分为两种：
   1、事前预防型。如智能指针等。
   2、事后查错型。如泄漏检测工具。
   后面我会继续优化和更新我的博客，感谢大家的支持，相信我们会越来越好！