【C++】内存管理

🚀个人主页：奋斗的小羊 🚀所属专栏：C++ 很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

---

前言

C++提供了对内存的精细控制，允许程序员以动态和手动的方式分配和释放内存。这种能力既带来强大的灵活性，也伴随着一定的挑战。

---

💥1、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. globalVar在：数据段
2. staticGlobalVar在：数据段
3. staticVar在：数据段
4. localVar在：栈
5. num1 在：栈
6. char2在：栈
7. *char2在：栈
8. pChar3在：栈
9. *pChar3在：代码段
10. ptr1在：栈
11. *ptr1在：堆

• pChar3在栈区，它所指的对象在代码段
• ptr1、ptr2、ptr3在栈区，它们所指的对象在堆区

| 说明：

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

---

💥2、C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

💥2.1new、delete操作内置类型

int main()
{
	int* p1 = new int;//申请一个int类型对象
	int* p2 = new int[5];//申请5个int类型对象

	delete p1;
	delete[] p2;

	int* p3 = new int(1);//申请一个int对象并初始化为1
	int* p4 = new int[5] {0};//申请5个int对象并初始化为全0
	int* p5 = new int[5] {1, 2, 3};//申请5个int对象并将前三个依次
								   //初始化，其他全为0

	delete p3;
	delete[] p4;
	delete[] p5;

	return 0;
}

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

new和delete的出现对于内置类型意义不大，真正有很大意义的其实是对自定义类型。

---

💥2.2new、delete操作自定义类型

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

class A
{
public:
	A(int a1 = 0, int a2 = 0)
		:_a1(a1)
	{
		cout << "A(int a1 = 0, int a2 = 0)" << endl;
	}

	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A & aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	A* p1 = new A(1);
	A* p2 = new A(2, 2);

	delete p1;
	delete p2;

	//1.
	A a1(1, 1);
	A a2(2, 2);
	A a3(3, 3);
	A* p3 = new A[3]{ a1, a2, a3 };
	
	//2.
	A* p4 = new A[3]{ A(1, 1), A(2, 2), A(3, 3) };

	//3.
	A* p5 = new A[3]{ (1, 1), (2, 2), (3, 3) };

	delete[] p3;
	delete[] p4;
	delete[] p5;

	return 0;
}

---

💥3、operator new与operator delete函数

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

下面是operator new与operator delete的底层实现逻辑：

//operator new：该函数实际通过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)

通过上述两个全局函数的实现知道：

• operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常
• operator delete 最终是通过free来释放空间的

---

💥4、new和delete的实现原理

💥4.1 内置类型

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

---

💥4.2 自定义类型

| 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[]中调用operator delete来释放空间

---

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

---

💥6、操作符不匹配使用的隐患

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

如果不匹配使用呢？

#include <iostream>
using namespace std;

class A
{
public:
	A(int a1 = 0, int a2 = 0)
		:_a1(a1)
	{
		cout << "A(int a1 = 0, int a2 = 0)" << endl;
	}

	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A & aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

class B
{
	//...
private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	B* p1 = new B[10];
	delete p1;

	return 0;
}

上面申请了10个B类类型，但我们使用delete释放连续的10个空间，编译器没有报错正常编译运行通过。

#include <iostream>
using namespace std;

class A
{
public:
	A(int a1 = 0, int a2 = 0)
		:_a1(a1)
	{
		cout << "A(int a1 = 0, int a2 = 0)" << endl;
	}

	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A & aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

class B
{
	//...
private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	//B* p1 = new B[10];
	//delete p1;

	A* p2 = new A[10];
	delete p2;

	return 0;
}

而当我们用相同的代码对A类测试，结果却是编译器报错。这是为什么呢？

A类和B类中都是两个整型，应该都是需要80个字节，但当我们转到反汇编查看时可以发现，B类申请的空间大小和我们预期的一样，但是A类多申请了4个字节空间。

p1指针指向空间开头，而p2指针没有指向空间开头，我们知道释放空间只能释放空间开头的地址，不能从半路释放，所以当A类时报错。那为什么A类时比B类多申请了4个字节的空间呢？
这4个字节的空间存的是类型个数N，为了后面调用N次析构函数，而B类时没有存类型个数是因为B类中没有显示的写析构函数，并且B类中没有指向资源也可以不需要析构函数，所以编译器直接将这一步优化掉了。

有时候我们不规范地去使用操作符编译器也不会报错，但这只是偶然的，也许是编译器将我们的错误优化了。
规范起见一定要正确匹配使用，不要错配。

---

总结

• new和delete：用于申请和释放单个空间
• new[] 和 delete[]：用于申请和释放连续的空间
• new和delete相较于malloc和free最大的优势在于对类类型自动调用构造和析构函数