我与C++的爱恋：C++内存管理

​

​

🔥个人主页：guoguoqiang. 🔥专栏：我与C++的爱恋

本篇文章我们详细讲解c++中的动态内存管理
​
​

一、C/C++内存分布

我们先看一下c/C++中的内存划分

数据段就是我们所说的全局变量，代码段是我们所说的常量区，我们需要重点关注的是堆区（malloc等），这部分是由我们自己控制的
现在再来做一下这个题练习一下：

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";//隐含"/0"
  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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？1 staticGlobalVar在哪里？2
staticVar在哪里？3 localVar在哪里？4
num1 在哪里？5

char2在哪里？6 *char2在哪里？7_
pChar3在哪里？8 *pChar3在哪里？9
ptr1在哪里？10__ *ptr1在哪里？11
1-----5 C C C A A
6-----11 A A A D A B
全局变量，静态变量 都在静态区。

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

二、C语言中动态内存管理

在C语言中，动态内存管理是通过一组标准库函数完成的，包括malloc, calloc, realloc, 和 free。
malloc
用法：void* malloc(size_t size);
功能：分配指定字节数的未初始化内存。它返回一个指向分配的内存的指针。如果分配失败，返回NULL。
示例：int* ptr = (int*)malloc(sizeof(int) ); 这行代码为1个整数分配了内存

calloc(相当于malloc+memset)
用法：void* calloc(size_t num, size_t size);
功能：为指定数量的元素分配内存，每个元素的大小也在参数中指定，并自动初始化所有位为0。如果分配失败，返回NULL。
示例：int* ptr = (int*)calloc(4, sizeof(int)); 这行代码为4个整数分配了内存，并将它们初始化为0。

realloc(可以分为两种，原地扩和异地扩)
用法：void* realloc(void* ptr, size_t size);
功能：调整之前调用malloc或calloc分配的内存块的大小。如果新的大小大于原始大小，可能会移动内存块到新的位置以提供足够的连续空间。如果realloc的第一个参数是NULL，它的行为就像malloc。
示例：ptr = (int*)realloc(ptr, sizeof(int) * 8); 这行代码将之前分配的内存大小调整为8个整数的大小。

free（只能用来释放主动mallloc等的空间）
用法：void free(void* ptr);
功能：释放之前通过malloc, calloc, 或 realloc分配的内存。一旦内存被释放，那块内存就不能再被访问了。
注意：尝试释放未经分配的内存块或多次释放同一个内存块是不安全的，可能导致未定义行为。

当使用realloc时，如果分配失败，原始内存不会被释放。因此，建议先将realloc的返回值赋给一个临时指针，以检查是否分配成功，再重新赋值给原始指针，以避免内存泄漏。
始终确保只对通过malloc, calloc, 或 realloc分配的指针使用free，并且每个分配的内存块只被free一次

三、C++内存管理方式

C++通过new和delete操作符进行动态内存管理。

1.new/delete操作内置类型

C++兼容C语言，内置类型动态申请，用法简化了，功能保持一致。

void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[10];
//动态申请10个int类型的空间并初始化前五个为1，2，3，4，5，后五个为0；
int* ptr7 = new int[10]{1,2,3,4,5};
delete ptr4;//单个对象
delete ptr5;
delete[] ptr6;//多个对象
delete[] ptr7;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

struct ListNode
{
	ListNode* _next;
	int _val;

	ListNode(int val)
		:_next(nullptr)
		,_val(val)
	{}
};

struct ListNode* CreateListNode(int val)
{
	struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->_next = NULL;
	newnode->_val = val;
	return newnode;
}

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

这是c语言构造一个节点并完成初始化的过程，我们来看c++的实现：

int main()
{
	ListNode* mode1 = new ListNode(1);
	return 0;
}
1
2
3
4
5

new 和 malloc最大区别是 new对于自定义类型除了开空间还会调用构造函数,
delete 和 free最大区别是delete对于自定义类型除了开空间还会调用析构函数.
不过对于内置类型来说几乎一模一样。

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 = new A(1);
	delete p1;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

四、operator new与operator delete函数

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

new=(operator new(malloc))+构造函数
delete=(operator delete(free))+析构函数

void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	void* p;
	while ((p = malloc(size)) == 0)
		if (_callnewh(size) == 0)
		{
			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
			static const std::bad_alloc nomem;
			_RAISE(nomem);
		}
	return (p);
}

1
2
3
4
5
6
7
8
9
10
11
12
13

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

通过上述两个全局函数的实现知道，operator new实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operatordelete 最终是通过free来释放空间的

五、new和delete的实现原理

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

自定义类型：（一定要匹配使用）
new的原理

1. 调用operator new函数申请空间
2. 在申请的空间上执行构造函数，完成对象的构造

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 = new A(1);
	delete p1;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作
2. 调用operator delete函数释放对象的空间

class Stack
{
public:
	Stack()
	{
		_a = (int*)malloc(sizeof(int) * 4);
		_top = 0;
		_capacity = 4;
	}

	~Stack()
	{
		free(_a);
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack* pst = new Stack;
	delete pst;
	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

先要调用析构函数再进行释放

new T[N]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2. 在申请的空间上执行N次构造函数

delete[]的原理

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释
   放空间

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 = new A;
	A* p2 = new A[10];
	delete p1;
	delete[]p2;
	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

A* p2 = new A[10];//计算*p2的大小发现为44，而不是四十，因为还额外开辟了4个byte的大小来存放对象个数。

存储对象个数，方便delete[]知道有多少个对象，要调用多少次析构。
如果是开辟内置类型就不会存储对象个数，因为不需要调用析构函数。

int*p1=new int[10]//他的大小为40byte
1

六、定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象

使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如
果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

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));//p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	new(p1)A;//对已有空间，显式调用构造
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化

七、概念

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

2.内存泄漏

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内
存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对
该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现
内存泄漏会导致响应越来越慢，最终卡死。
分类
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一
块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分
内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

本节内容到此结束！！求大家三连啊！ 感谢观看！！