C++内存管理详解

---

C++内存划分
栈：函数调用，建立栈帧（形参、局部变量等）
32位下栈Linux 8M
数据段–静态区
代码段–常量区
堆：程序运行过程中按需求申请和释放空间
堆32位2G左右
【说明】
1、栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的
2、内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
3、堆用于程序运行时动态内存分配，堆是可以向上增长的
4、数据段存储全局数据与静态数据
5、代码段：可执行的代码/只读常量

接下来看一道题目：

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

char2在栈上开5字节空间，把字符串拷贝过去
*char2是首元素a，也在栈上第一个空间
pchar3是在栈上的
*pchar3是在常量区

malloc/calloc/realloc的区别
calloc会初始化，相当于是malloc+memset，按字节初始化，空间每个字节都初始化为0
realloc扩容分为原地扩和异地扩

C++内存管理方式

new和delete操作符：

int main()
{
	// 动态申请int和5个int数组
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = (int*)malloc(sizeof(int) * 5);
	int* p3 = new int;
	int* p4 = new int[5];
	// new失败了之后是抛异常 而不是返回空
	// new的空间没有初始化

	int* p5 = new int(5); // 创建了这个空间，并给里面内容初始化为5

	// c++11之后支持使用{}列表初始化
	int* p6 = new int[5]{ 1,2 }; // 剩下的默认为0
	
	free(p1);
	free(p2);
	delete p3;
	delete[] p4;

	p1 = nullptr;
}
/*
对于内置类型申请释放，是用法上的区别
对于自定义类型，就不仅仅是用法上的区别了
new动态申请的对象，申请空间+调用构造函数初始化（先申请空间，在初始化）
delete释放对象时，调用析构函数清理对象中的资源，释放空间（先清理资源，在释放空间）
*/

new在堆上申请空间，然后调用构造函数初始化对象
delete先调用指针类型析构函数，然后释放空间给堆上

C++提出new和delete是解决两个问题：
1、自定义类型对象自动申请的时候，初始化和清理的问题。new/delete会调用构造函数与析构函数
2、new失败后要求抛异常，这样子才符合面向对象的出错处理机制
注：
1、delete和free一般不会失败，如果失败了，都是释放空间上存在越界或者释放指针位置不对
2、malloc/free 、new/delete、new[]/delete[]一定要匹配使用，否则可能会崩溃

class Stack
{
public:
	Stack(int capacity = 4)
		: _top(0)
		, _capacity(capacity)
	{
		_a = new int[capacity];
	}
	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_capacity = _top = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack st1;
	Stack* pst2 = new Stack; // 开空间 + 构造函数初始化
	delete pst2;

	return 0;
}

处理错误的方式

面向对象语言，处理错误的方式一般是抛异常，C++中也要求出错抛异常
面向过程语言，处理错误的方式一般是返回值+错误码解决

int main()
{
	char* p1 = (char*)malloc(10);
	if (p1 == nullptr)
	{
		printf("%d ", errno); // 打印错误码
		perror("malloc fail"); // 把错误原因打出来
		exit(-1);
	}
	return 0;
}

operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间
operator new：该函数实际是通过malloc来申请空间的，malloc申请空间成功时直接返回，否则执行用户提供的空间不足应对措施。如果用户提供该措施就继续申请，否则就抛异常
operator delete最终是通过free来释放空间的
这两个是函数，而不是重载的！

new和delete的实现原理：

内置类型：如果申请的是内置类型空间，new和malloc，delete和free基本类似，不同的是：new/delete申请和释放的是单个元素的空间，new[]/delete[]申请的是连续的空间，而且new会在申请空间失败时抛异常。
自定义类型：
new原理：
1、调用operator new函数申请空间
2、在申请的空间上执行构造函数，完成对象的构造
delete原理：
1、在空间上执行析构函数，完成对象中资源的清理
2、调用operator delete函数释放对象的空间
new T[N]原理：
1、调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2、在申请的空间上执行N次构造函数
delete[]原理：
1、在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2、调用operator delete[]释放空间，实际在operator 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在释放空间前就会调用析构函数完成空间中资源的清理

内存泄漏

什么是内存泄漏？
动态申请的内存不使用了，也没有主动释放就存在内存泄漏；内存泄漏并不是指存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去对该段内存的控制，因而造成内存的浪费
内存泄漏的危害：
1、出现内存泄漏的进程正常结束，进程结束时这些内存会还给操作系统，不会有什么特别大的伤害
2、出现内存泄漏的进程非正常结束，比如僵尸进程，危害很大，系统会越来越慢，甚至卡死宕机
3、需要长期运行的程序，出现内存泄漏，危害很大，系统会越来越慢，甚至卡死宕机

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

解决方案
1、事前预防：如智能指针
2、事后查错：泄漏检测工具