《从崩溃到精通：C++ 内存管理避坑指南，详解自定义类型 new/delete 调用构造 / 析构的关键逻辑》

🔥草莓熊Lotso：个人主页

❄️个人专栏：《C++知识分享》《Linux 入门到实践：零基础也能懂》

✨生活是默默的坚持，毅力是永久的享受。

🎬博主简介：

前言：

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击人工智能教程跳转到网站。”

如果你写过 C++ 项目，大概率遇到过这些 “崩溃瞬间”：调试时突然弹出的 “内存访问冲突” 弹窗、上线后监控面板里莫名飙升的内存占用、排查了 3 天才找到的 “隐藏式内存泄漏”…… 这些问题的根源，几乎都指向同一个核心 ——内存管理。

一.C/C++内存分布

--其实内存管理我们并不陌生。从C语言开始，我们就经常接除到内存相关问题，大家对此一定都有一定的了解，所以今天我们先通过一段代码和相关问题来引入。

1.1 内存分布问题

#include<iostream>
using namespace std;

int globalVar = 1;
static int staticGlobalVar = 1;
void main()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	const char* pChar3 = "abcd";

	*char2 += 1;
	//(*(char*)pChar3) += 1;

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

	const int i = 10;
	int j = 1;
	cout << &i << endl;
	cout << &j << endl;
	cout << (void*)pChar3 << endl;
}

1.选择题： 选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

• globalVar在哪里？__C__
• staticGlobalVar在哪里？_C_
• staticVar在哪里？__C__
• localVar在哪里？__A__
• num1 在哪里？__A__

解析：globalVar全局变量在数据段， staticGlobalVar静态全局变量在静态区，staticVar静态局部变量在静态区 ，localVar局部变量在栈区，num1局部变量在栈区

• char2在哪里？__A__
• *char2在哪里？__A__
• pChar3在哪里？__A__
• *pChar3在哪里？__D__
• ptr1在哪里？__A__
• *ptr1在哪里？__B__

解析： char2局部变量在栈区 ，char2是一个数组，把后面常量串拷贝过来到数组中，数组在栈上，所以*char2在栈上 pChar3局部变量在栈区 ，*pChar3得到的是字符串常量字符在代码段 ptr1局部变量在栈区 ，*ptr1得到的是动态申请空间的数据在堆区 2.填空题：

• sizeof(num1) = __40__; //数组大小,10个整形数据一共40字节
• sizeof(char2) = __5__; //包括\0的空间 strlen(char2) = __4__;//不包括\0的长度
• sizeof(pChar3) = __4__; //pChar3为指针 strlen(pChar3) = __4__;//不包括\0的长度
• sizeof(ptr1) = __4__;//ptr1是指针

--大家如果还有不理解的可以试试自己画图看看

1.2 概念说明

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

二.C/C++中动态内存管理方式解析

2.1 C语言中动态内存管理方式：malloc/calloc/realloc/free

--C语言中的动态内存管理方式我们之前就学过，这里就不过多解释了，大家有想详细了解的可以看下下面这篇博客。

【C语言动态内存管理】--动态内存分配的意义，malloc和free，calloc和realloc，常见的动态内存的错误，动态内存经典笔试题分析，柔性数组，总结C/C++中程序内存区域划分-CSDN博客

我们直接来看一段代码并回答一下相关问题：

#include<iostream>
using namespace std;
int main()
{
	// 1.malloc/calloc/realloc的区别是什么？
	int* p2 = (int*)calloc(4, sizeof(int));
	int* p3 = (int*)realloc(p2, sizeof(int) * 50);
	cout << p2 << endl;
	cout << p3 << endl;

	// 这里需要free(p2)吗？
	free(p3);
}

• 第一个问题在后面的面试题中会给大家讲解，这里先说一下这里是不需要free(p2)的

--因为我们在realloc时有两种情况，第一种是原地扩容那么p2和p3的地址是一样的，释放一次就行了。第二种异地扩容的话，原来p2指向的内存块已经被realloc自动释放了，所以也是不需要考虑手动释放p2的。

面试题：

1.malloc/calloc/realloc的区别？

• malloc：分配指定字节内存，不初始化，数据随机。
• calloc：分配内存并初始化为 0，需指定元素个数和单个元素字节数。
• realloc：调整已分配内存大小，可扩容或缩容，可能复用原内存或重新分配并复制数据，有两种情况，原地扩容或者异地扩容，这个在上面也提到过。

2.malloc的实现原理？

• 基于brk（调整数据段地址）和 mmap（映射新内存区域）系统调用，结合内存池管理（按大小分类维护空闲块，分配时快速匹配，减少系统调用开销）

--这个问题大家可以学到后面再来看，通过这个视频来深入了解一下。

参考视频：【CTF】GLibc堆利用入门-机制介绍_哔哩哔哩_bilibili

2.2 C++中内存管理方式

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

2.1.1 new/delete操作内置类型

#include<iostream>
using namespace std;
int main()
{

	int* p5 = new int;	    // 单个对象
	int* p6 = new int[10];  // 数组

	int* p7 = new int(5);	    // 单个对象
	int* p8 = new int[10] {1, 2, 3, 10};  // 数组

	delete p5;
	delete[] p6;
	delete p7;
	delete[] p8;
}

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

--大家可能会觉得这些操作我们之前使用malloc等操作也可以实现，虽然没这么方便，但也不是完全不行，那C++到底为什么要引入新的new/delete呢？我们接着往下看看自定义类型的操作吧~

2.1.2 new/delete操作自定义类型

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

struct ListNode
{
	ListNode* _next;
	int _val;

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

int main()
{
	// 只开空间，不调用构造初始化，不太好使
	A* p1 = (A*)malloc(sizeof(A));

	A* p2 = new A;
	A* p3 = new A(10);

	delete p2;
	delete p3;

	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);


	return 0;
}

--我们可以发现new/delete在处理自定义类型的时候会比malloc等操作好很多，会调对应的构造函数和析构函数。

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

2.1.3 申请空间失败时的处理：

--malloc在空间申请失败后会返回NULL,而new在申请空间失败时会抛异常，大家注意看代码注释

#include<iostream>
using namespace std;
//这个程序退出码不为0，异常退出，跟malloc不一样，new申请失败会抛异常
void func()
{
	int i = 1;
	int* ptr = nullptr;
	do {
		if (i == 493)//为了方便调试
		{
			int x = 0;
		}

		ptr = new int[1024 * 1024];//throw
		cout << i++ << ":" << ptr << '\n';
	} while (ptr);
	cout << i++ << ":" << ptr << '\n';
}
int main()
{
	try 
	{
		func();//可以直接跳跃函数到异常
	}
	catch(const exception& e)
	{
		cout << e.what() << '\n';//打印错误信息
	}
	return 0;
}

--这里利用了一个小技巧方便调试，当然也可以用编译器那个条件断点。我这里还有点问题，大家改成494更方便一点。(我这里就不改了)

--我们发现到495时出现异常，直接跳转到打印错误信息

三.operator new与operator delete函数(重点内容)

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

系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过

operator delete全局函数来释放空间。

--我们来看下底层代码

3.1 operator new函数

//operator new：该函数实际通过malloc来申请空间，当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);
}

3.2 operator delete函数

/*
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来释放空间的

3.3 补充扩展

#include<iostream>
using namespace std;
class A 
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A();" << this << '\n';
	}
	~A()
	{
		cout << "~A();" << this << '\n';
	}
private:
	int _a;
};

int main()
{
	//A* p2 = (A*)operator new(sizeof(A));//可以显示调用

	//可以看看反汇编
	A* p1 = new A(1);
	delete p1;

	A* p2 = new A[10];//看反汇编为啥会是44，而不是40;
	//但是把析构注释掉就又是40了
	delete[] p2;

	return 0;
}

先观察一下new和delete的底层反汇编：

• 从底层反汇编来看，new在使用时会先调用operator new再调用构造函数，delete会先调用一个封装好的函数，这个函数再去先调用析构再调用operator delete的

再看一个小细节，我们这里看p2底层为啥空间会是44而不是40：

• 这是因为在 C++ 中，当使用new[ ]动态分配对象数组时，如果类 A 有析构函数，编译器会在分配的内存块开头额外存储一个 “数组长度信息”，用于在delete[ ]时知道需要调用多少次析构函数。

具体分析：

1. 有析构函数的情况：
   • 假设 sizeof(A) 是 4（比如 A 是简单的类，包含一个 int 成员等）。
   • 当用new A[10] 时，编译器实际分配的内存不仅要存 10 个A对象（共 10×4=40 字节），还要额外存一个 “数组长度”（通常是 4 字节，用来记录数组元素个数10）。
   • 所以总分配内存是 40+4=44 字节，这就是反汇编看到44的原因。
   • 后续delete[ ]时，会根据这个额外存储的长度信息，调用 10 次A的析构函数，再释放内存。
2. 没有析构函数的情况：
   • 如果把A的析构函数注释掉，编译器判断不需要额外记录 “数组长度”（因为这里的A类没啥需要释放的资源，不需要调用析构函数，也就不需要知道要调用多少次）。
   • 此时分配的内存就是 10×4=40 字节，所以反汇编看到的是 40 。

• 简单来说，类是否有析构函数，会影响new[ ]时是否额外分配 “数组长度信息” 的空间，从而导致总分配内存大小不同。
• 值得一提是这也就是为啥我们前面提到new和delete要匹配使用，如果不匹配的话那这里释放的就有问题了，从中间那个位置开始释放掉了。但是我们知道空间的释放只可以从起始位置开始释放，不可以分段释放

五.new和delete的底层实现原理

5.1 内置类型

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

5.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来释放空间

六.定位new表达式(placement-new)（了解即可）

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

使用格式：

• new (place_address) type或者new (place_address) type(initializer-list)
• place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：

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

#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A();" << this << '\n';
	}
	~A()
	{
		cout << "~A();" << this << '\n';
	}
private:
	int _a;
};

//定位new表达式的使用
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)operator new(sizeof(A));
	//显示调用构造函数
	new(p1)A(1);//有参数就需要传，这里其实可以传也可以不传，看你实现的构造函数

	p1->~A();//析构可以直接这样用，构造不行;
	operator delete(p1);

	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
}

七.malloc/free和new/delete的区别

7.1 共同点：

都是从堆上申请空间，并且需要用户手动释放。

7.2 不同点：

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

这些特点大家不用死记硬背，结合着用法，核心特性，原理来记忆就可以了，其中第六点比较重要。

结尾：

往期回顾：

《吃透 C++ 类和对象（中）：拷贝构造函数与赋值运算符重载深度解析》

《吃透 C++ 类和对象（中）：const 成员函数与取地址运算符重载解析》

《吃透 C++ 类和对象（下）：从初始化列表到编译器优化，7 大核心考点让你彻底告别面试卡壳！》

结语：C++ 内存管理是门 “实践出真知” 的学问，从内存分布到new/delete底层，每一个知识点都得在代码里摸透，希望这篇博客能帮你扫清疑惑，要是还有搞不懂的，评论区见～。如果文章对你有帮助的话，欢迎评论，点赞，收藏加关注，感谢大家的支持。

✨把这些内容吃透超牛的！放松下吧✨ ʕ˘ᴥ˘ʔ づきらど