C/C++内存管理【C++】

一、 C/C++内存分布

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";
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. 选择题：
   选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
   1.globalVar在哪里？____ 2.staticGlobalVar在哪里？____
   3.staticVar在哪里？____ 4.localVar在哪里？____
   5.num1 在哪里？____
   6.char2在哪里？____ 7.*char2在哪里？___
   8.pChar3在哪里？____ 9.*pChar3在哪里？____
   10.ptr1在哪里？____ 11.*ptr1在哪里？____
   选择答案：
   C C C A A A A A D A B
2. 填空题：
   sizeof(num1) = ____;
   sizeof(char2) = ____; strlen(char2) = ____;
   sizeof(pChar3) = ____; strlen(pChar3) = ____;
   sizeof(ptr1) = ____;
   答案: 40 5 4 4/8 4 4/8

C语言中动态内存管理方式：malloc/calloc/realloc/free等
C语言动态内存详细介绍 请猛戳此处

1. C++内存管理方式

C++提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理

当然C语言内存管理方式在C++中可以继续使用

(1) new和delete操作内置类型

只分配空间

// 例 1 在堆上分配一个空间
	int* p1 = new int; //表示在堆上动态分配一个整数的大小的内存，返回的地址赋值给指针变量 p1
	//...
	delete p1;	//使用 new 分配的内存必须在不再需要时手动释放，以避免内存泄漏

// 例 2 在堆上分配多个空间
	int* p2 = new int[10]; //表示在堆上要多个int对象,p2 是一个指向整数的指针，它被初始化为新分配的数组的首地址
	//...
	delete[] p2;		   //注意释放的形式

分配空间同时初始化

// 例 1 分配一个空间并初始化
	//在堆上动态分配了一个整型变量并初始化为10，指向该整型变量的指针赋值给指针变量p3
	int* p3 = new int(10);
	//...
	delete p3;

// 例 2 分配一个空间并初始化
	int* p4 = new int[10] {1,2,3,4,5};	//在堆上动态分配了多个空间并部分初始化，然后将指向该数组首元素的指针赋值给指针变量p4
	//...
	delete[] p4;

小总结：
申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]

(2) new和delete操作自定义类型

// 例如 链表
struct ListNode
{
	~ListNode()
	{
		_next = nullptr;
		_prev = nullptr;
		_val = 0;
		cout << "~ListNode()" << endl;
	}
	ListNode* _next;
	ListNode* _prev;
	int _val;

	//构造
	ListNode(int val)
		:_next(nullptr)
		,_prev(nullptr)
		,_val(val)
	{}
};

int main() 
{
	//new操作符 在为自定义类型申请空间时，会去调用构造函数
	//如果new失败了后抛异常，不需要手动检查
	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	ListNode* node3 = new ListNode(3);

	//delete操作符 会去调用析构函数
	delete node1;
	delete node2;
	delete node3;

	return 0;
}

小总结：
在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会

二、 operator new与operator delete函数

new 和 delete 是进行动态内存申请和释放的操作符

operator new 和 operator delete 是 系统提供的全局函数

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

operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

	// 对于内置类型,本质和malloc并没有什么区别
	int* p1 = (int*)operator new(10*4);	
	//注意 operator new 不是运算符重载
	//int *p1 = (int*)new(10*4);	//error,运算符重载

	//对于自定义类型,
	A* ptr1 = new A;
	A* ptr2 = new A[10];	//动态分配了一个包含10个 A 类型对象的数组

自定义类型 汇编

调用的底层顺序

operator new 是对 malloc 的封装，为了 解决失败后进行抛异常 和 实现new

new的原理：调用operator new函数申请空间，再申请的空间上执行构造函数，完成对象的构造

new A[n]的原理 : 调用operator new[]函数，再operator new[]中实际调用operator new函数完成n个对
象空间的申请,再申请的空间上执行n次构造函数

operator delete: 该函数最终是通过free来释放空间的

对于内置类型的delete本质上和free区别不大

对于自定义类型

	//对于自定义类型,
	A* ptr1 = new A;	//operator new + 1次构造
	A* ptr2 = new A[10];	//operator new[] + 10次构造

// 注意 这里是先进行 析构 再去调用 operator delete
	delete ptr1;	// 先 1次析构 再去调用operator delete
	delete[] ptr2;	// 先 10次析构 再去调用 operator delete[]

operator new 和 operator new[] 的区别 : 在汇编底层，如果有需要时，operator new[] 首地址前多开辟空间，用来记录所要进行析构的次数

三、 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需要捕获异常

特性层面上 :

申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数和析构函数；
new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

四、内存泄漏

指程序在申请内存后，无法释放已不再使用的内存空间的现象。简单来说，就是程序在动态分配了一块内存后，丢失了对该内存区域的控制权，导致即使程序不再需要这块内存，操作系统也无法将其回收供其他进程或程序使用。

简单地说：
一块已经不在使用的内存空间，没有释放

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

C++中预防和解决内存泄漏的方法包括：

手动管理：确保每一块动态分配的内存都有对应的释放操作，即对每一个 new 操作都应有一个相应的 delete 操作。

智能指针：使用C++11引入的智能指针，如 std::unique_ptr、std::shared_ptr
等，它们会在适当的时候自动释放所管理的对象，大大减少了手动管理内存带来的问题。

容器管理：使用STL容器如 std::vector、std::map 等，它们内部会自动管理内存。

内存检测工具：利用内存分析工具如Valgrind、AddressSanitizer等进行调试和检测，找出程序中的内存泄漏点。

编程范式：采用RAII(Resource Acquisition Is
Initialization)原则编写代码，确保资源在创建的同时就确定了其生命周期。

良好的编程习惯：避免循环内反复分配内存而不释放，注意在函数返回前释放临时分配的内存等。