【C++】——内存管理

😀😀前言

好久没更新了，五一小长假，有点玩脱了，今天赶紧补一篇博客，回回状态

一 c/c++内存分配

下面看下面一段代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int a = 1;
static int b = 1;
int main()
{
	
	static int n = 1;
	int m = 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);
	return 0;
}

你们可以看看各个变量是存在哪里的

1. 对于a,b来说因为一个是全局变量，一个是静态变量，所以都是放在静态区的

（不知道谁告诉我，全局变量是开在堆上的，搞得我学到这里已经怀疑人生了）

2. n也是静态变量所以也是静态区，m是函数栈帧里面的一个变量，所以是存在栈里面的

3. num1是一个局部变量，也是在栈区里面，char2也是

4. 对于pChar3来说，pChar3是一个指针，也是局部变量所以存在栈里面，但是指向的内容是一个字符串常量，所以*pChar3存在代码段

5. 对于ptr1,ptr2,ptr3,来说，因为都是指针所以都是存在栈里面，但是他们指向的内容是通过扩容函数开出来的，所以都是在堆上

看上面的图可以看出各个内存的区域划分

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

二 C语言的动态内存管理方式

C语言中有下面几个函数来管理内存

malloc / calloc / realloc / free

对于这几个，我们可能并不陌生，所以我们就不展示用法了，着重说一下他们的区别

(ง •_•) malloc就是开辟一片空间

(ง •_•）calloc可以理解为比malloc更加负责一点，开辟空间还会初始化

(ง •_•) realloc是是一个扩容函数，如果空间不够，可以用realloc来扩容，但是realloc不单单只是扩容，它也能用来开辟空间

每次用他们开辟空间以后，我们都需要用free来释放空间，不然就会内存泄漏

🎈内存泄漏

既然说到了内存泄漏，这里就要补充一点，所虽然在之前的博客中提到过，但是那个时候理解不深

当我们开辟空间以后，那么我们一般会去用一个指针去接收这个空间的地址，如果这个指针是函数栈帧里面的，那么当函数结束的时候，我们没有去释放空间，那么指针会随着栈帧的销毁而销毁，因为是局部变量，但是这片空间也就留下来了，同时这篇空间你还不能访问，这个是重点，这个就是内存泄漏，那么随着内存泄漏越来越多，那么空间的利用率就越来越少，程序运行起来就会越卡

更加形象的理解就是，指针是一把房间的钥匙，你把钥匙丢了，那这个房间就打不开也找不到了，随着这样的房间越来越多，那么人也会越来越拥挤

所以对于内存泄漏需要重视

三 C++内存管理方式

C语言里面的内存管理函数也可以用，只不过用起来比较麻烦，而且在有些情况下不能处理，所以C++推出了自己的内存管理方式new/delete操作符进行动态内存管理

C语言的函数对于自定义类型是无法下手的，这样是为啥要推出这两个操作符的原因之一

1.对于内置类型

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int main()
{
	int* ptr1 = new int;//动态申请一个int类型的空间
	int* ptr2 = new int(10);//动态申请一个int类型的空间并且初始化为10
	int* ptr3 = new int[10];//动态申请10个int类型空间
	int* ptr4 = new int[10]{0};//动态申请10个int类型的空间并且初始化为10
	delete ptr1;
	delete ptr2;
	delete[]ptr3;
	delete[]ptr4;
	return 0;
}

这里的new和delete要搭配使用，比如new和delete搭配，new[]和delete[]搭配，如果混搭那就会出错误

2.对于自定义类型

上面提到了C语言的函数不能处理自定义类型，但是new和delete可以

原因就是new / delete 和 malloc / free最大区别是 new / delete对于【自定义类型】除了开空间还会调用构造函数和析构函数

#define _CRT_SECURE_NO_WARNINGS 1
#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;
}

new/delete和malloc/free区别

可以看上面的调试视频，可以更好的去理解

3.new和delete的实现原理

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

对于operator new和operator delete，他们分别通过malloc和free，开辟空间和释放空间

所以new和delete底层还是用的malloc和free

不同的是operator new通过malloc申请空间，如果成功直接返回，如果失败那么就抛异常

所以我们在用new申请空间就没必要像malloc那样去判断，new如果申请失败会抛异常

4. 定位new

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

#define _CRT_SECURE_NO_WARNINGS 1
#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;
};
// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);

	//这里使用operator new和上面malloc实际是一样的
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2); //是类型的初始化列表
	return 0;
}

从代码中我们可以看出，我们需要主动去调用析构函数，因为delete调用的析构函数只能与常规new相匹配，对于定位new是处理不到的，所以这里要去主动释放空间

总结来说，定位new需要主动释放空间是因为它本身并不负责分配内存，而是假设你已经拥有了一块内存，并在这块内存上直接构造对象。因此，你需要自己负责在该对象不再需要时手动释放内存。