震惊！90% 的程序员都不知道的 new / delete 底层黑幕

最新推荐文章于 2025-08-04 14:41:19 发布

原创最新推荐文章于 2025-08-04 14:41:19 发布 · 748 阅读

54 ·

CC 4.0 BY-SA版权

文章标签：

#开发语言 #C++ #内存管理 #new/delete

C++ 炼魂场：从青铜到王者的进阶之路专栏收录该内容

11 篇文章

订阅专栏

💻作者简介：曾与你一样迷茫，现以经验助你入门 C++。
💡个人主页：[@笑口常开xpr 的个人主页]
(https://blog.csdn.net/2301_78847073?spm=1000.2115.3001.5343)
📚系列专栏：C++ 炼魂场：从青铜到王者的进阶之路
✨代码趣语：new[ ] 与 delete[ ] 是内存世界的 “连锁反应”，必须成对出现。若误用单元素操作符，将引发内存崩溃的多米诺效应。
💪代码千行，始于坚持，每日敲码，进阶编程之路。
📦gitee 链接：gitee

在这里插入图片描述

C++ 内存管理是从 “手动分配” 到 “对象自动管理” 的升级。从 C 的 malloc 到 C++ 的 new，不仅是语法变化，更是对 “对象生命周期” 的完整掌控。本文拆解 new / delete 的底层逻辑、与构造 / 析构函数的协同，以及内存泄漏的规避，帮你夯实基础。

程序中的数据

栈又叫堆栈，存储 非静态局部变量 / 函数参数 / 返回值 等等，栈是向下增长的。

内存映射段 是高效的 I / O 映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。

堆用于程序运行时动态内存分配，堆是可以向上增长的。

数据段（静态区） 存储全局数据和静态数据。

代码段（代码段） 可执行的代码 / 只读常量。

程序是以文件形式存储在磁盘中的。
在这里插入图片描述

C 语言中动态内存管理方式

动态内存分配
         C 语言是通过 malloc、realloc 和 calloc 来开辟空间的。
         malloc 用来在内存的堆区分配一块连续空间，但不会对分配的内存进行初始化。
         calloc 用来分配指定类型和大小的空间并且会把分配的内存全部初始化为 0。
         realloc 会将已经开辟的空间大小调整，也就是扩容。

C++ 内存管理方式

C++ 兼容 C 语言，C 语言的内存管理方式在 C++ 中同样适用。在 C++ 中 使用 new 和 delete 操作符 来管理内存。

new 和 delete

new 运算符：分配和初始化内存
delete 运算符：释放内存

基本语法

//分配单个对象
T* ptr = new T;        //默认初始化(内置类型未初始化,类类型调用默认构造函数)
delete ptr;
T* ptr = new T(value); //值初始化(内置类型初始化为指定值,类类型调用带参构造函数)
delete ptr;

//分配数组
T* arr = new T[n];     //分配包含n个元素的数组,默认初始化
delete[ ] arr;
T* arr = new T[n]();   //值初始化(C++11及以后)
delete[ ] arr;

在这里插入图片描述
注意
申请和释放单个元素的空间，使用 new 和 delete 操作符，申请和释放连续的空间，使用 new[ ] 和 delete[ ] 应该匹配起来使用。

代码示例

#include<iostream>
using namespace std;
void Test()
{
	//动态申请一个int类型的空间
	//C
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);
	//C++
	int* p2 = new int;
	delete p2;//free(p2);

	//动态申请10个int类型的空间
	//C
	int* p3 = (int*)malloc(sizeof(int) * 10);
	free(p3);
	//C++
	int* p4 = new int[10];
	delete[] p4;

	//动态申请一个int类型的空间并初始化为10
	//C
	int* p5 = (int*)calloc(10, sizeof(int));
	free(p5);
	//C++
	int* p6= new int(10);
	delete p6;
}
int main()
{
	Test();
	return 0;
}

相比于 C 语言，C++ 内存分配语法更简洁。

构造函数调用

对于类类型，new 会自动调用相应的构造函数。下面分别以 C 语言和 C++ 的分配内存进行比较。

C 语言

#include<iostream>
using namespace std;
struct ListNode
{
	int _val;
	struct ListNode* _next;
};
struct ListNode* BuyListNode(int x)
{
	//单纯的开空间
	struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->_next = NULL;
	newnode->_val = x;
	return newnode;
}
int main()
{
	struct ListNode* n1 = BuyListNode(1);
	struct ListNode* n2 = BuyListNode(2);
	struct ListNode* n3 = BuyListNode(3);
	return 0;
}

C++

#include<iostream>
using namespace std;
class ListNode
{
public:
	//构造函数
	ListNode(int x)
	//初始化列表
		: _val(x)
		, _next(NULL)
	//函数体
	{}
private:
	int _val;
	struct ListNode* _next;
};
int main()
{
	//开空间并调用构造函数
	ListNode* nn1 = new ListNode(1);
	ListNode* nn2 = new ListNode(2);
	ListNode* nn3 = new ListNode(3);
	return 0;
}

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

区别

特性	C 语言实现	C++ 实现
数据封装	结构体 + 外部函数	类 + 成员函数
内存分配	malloc()+ 手动初始化	new+ 构造函数自动初始化
错误处理	返回NULL+perror()	抛出异常
类型转换	显式转换	自动类型推导
生命周期	手动管理 (分配 / 释放)	构造函数 / 析构函数自动管理
代码复杂度	较高 (需要额外函数)	较低 (封装在类中)

注意
malloc 和 free、new 和 delete 匹配使用，不能乱用否则代码会报错。

operator new 与 operator delete 函数

new 和 delete 分别是内存开辟和释放的操作符，operator new 与 operator delete 是全局函数，new 在底层调用 operator new 全局函数来申请空间，delete 在底层通过 operator delete 全局函数来释放空间。

operator new
在这里插入图片描述

operator delete

#include<iostream>
using namespace std;
int main()
{
	int* p1 = (int*)operator new(sizeof(int));
	operator delete(p1);
	int* p2 = new int;
	delete(p2);
	return 0;
}

从上面的代码来看，operator new 和 operator delete 和 malloc 以及 free 的用法类似。面向对象语言处理失败后不使用返回值，会抛异常并捕获异常，捕获异常后会释放空间。
malloc

#include<iostream>
using namespace std;
int main()
{
	int* p1 = nullptr;
	do
	{
		p1 = (int*)malloc(1024 * 1024);//失败了返回NULL,申请的是虚拟内存
		cout << p1 << endl;
		} while (p1);
	return 0;
}

malloc 开辟空间失败后失败后程序会终止，并返回空指针。

new

#include<iostream>
using namespace std;
int main()
{
	int* p1 = nullptr;
	try
	{
		do
		{
			p1 = new int[1024 * 1024];
			cout << p1 << endl;
		} while (p1);
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

抛出异常
在这里插入图片描述

new 开辟空间失败后程序会抛出异常。使用 new 会调用 operator new，operator new 对 malloc 进行了封装，如果开辟空间失败会抛出 bad allocation。开辟空间成功后会调用构造函数。
与 new 类似，delete 是先调用析构函数清理资源，然后释放空间，释放空间时调用 operator delete，然后调用 free 函数。
在这里插入图片描述

#include<iostream>
using namespace std;
typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack(size_t capacity = 3)" << endl;
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
void TestStack()
{
	Stack s;
	s.Push(1);
	s.Push(2);
}
int main()
{
	//需要申请1个堆上的栈对象
	Stack* p1 = new Stack;
	delete p1;
	return 0;
}

在这里插入图片描述

new 和 delete 的实现原理

内置类型

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

自定义类型

new 的原理

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

delete 的原理

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

new T[N] 的原理

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

delete[ ] 的原理

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

定位 new（placement-new）表达式

定义

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

格式

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

代码示例

#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));
	//显示调用构造函数
	new(p1)A; //如果A类的构造函数有参数时,此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

在这里插入图片描述
任何类型的指针都是内置类型，内置类型不会自动调用构造函数和析构函数。只有自定义类型才能自动调用构造函数和析构函数。因为 p1 是内置类型需要手动调用构造函数和析构函数。

经典题目

malloc / free 和 new / delete 的区别

共同点

malloc / free 和 new / delete 都是从堆上申请空间，并且需要用户手动释放。

不同点

malloc 和 free 是函数，new 和 delete 是操作符
malloc 申请的空间不会初始化，new 可以初始化
malloc 申请空间时，需要手动计算空间大小并传递，new 只需在其后跟上空间的类型即可，如果是多个对象，[ ] 中指定对象个数即可
malloc 的返回值为 void*，在使用时必须强转，new 不需要，因为 new 后跟的是空间的类型
malloc 申请空间失败时，返回的是 NULL，因此使用时必须判空，new 不需要，但是 new 需要捕获异常
申请自定义类型对象时，malloc / free 只会开辟空间，不会调用构造函数与析构函数，而 new 在申请空间后会调用构造函数完成对象的初始化，delete 在释放空间前会调用析构函数完成空间中资源的清理。

内存泄漏

定义

内存泄漏是指程序在动态分配内存后，由于逻辑错误或设计缺陷，导致已分配的内存不再被使用，却未被释放，最终造成系统可用内存逐渐减少的现象。内存泄漏如果长期积累，可能导致程序性能下降、卡顿，甚至崩溃。

核心原因

动态分配的内存与指向它的指针失去关联，且无法被程序再次访问和释放。

危害

短期影响：程序占用内存持续增长，可能导致运行速度变慢（内存交换频繁）。
长期影响：对于长时间运行的程序，内存泄漏会逐渐耗尽系统内存，最终导致程序崩溃或被操作系统强制终止。
隐蔽性：单次内存泄漏可能微不足道，但长期积累会引发严重问题且排查难度较高。
在这里插入图片描述

总结

C++ 内存管理的核心是 “智能” - - - new / delete 结合构造 / 析构，实现对象从创建到销毁的自动化。相比 C 的手动操作，它降低了错误风险，但仍需注意匹配使用、避免指针滥用。掌握这些，既能应对面试，更能写出可靠代码。

震 惊！90% 的 程 序 员 都 不 知 道 的 new / delete 底 层 黑 幕

震 惊！90% 的 程 序 员 都 不 知 道 的 new / delete 底 层 黑 幕

程 序 中 的 数 据

C 语 言 中 动 态 内 存 管 理 方 式

C++ 内 存 管 理 方 式

new 和 delete

operator new 与 operator delete 函 数

new 和 delete 的 实 现 原 理

内 置 类 型

自 定 义 类 型

new 的 原 理

delete 的 原 理

new T[N] 的 原 理

delete[ ] 的 原 理

定 位 new（placement-new）表 达 式

定 义

格 式

代 码 示 例

经 典 题 目

malloc / free 和 new / delete 的 区 别

共 同 点

不 同 点

内 存 泄 漏

定 义

核 心 原 因

危 害

总 结

震惊！90% 的程序员都不知道的 new / delete 底层黑幕

震惊！90% 的程序员都不知道的 new / delete 底层黑幕

程序中的数据

C 语言中动态内存管理方式

C++ 内存管理方式

operator new 与 operator delete 函数

new 和 delete 的实现原理

内置类型

自定义类型

new 的原理

delete 的原理

new T[N] 的原理

delete[ ] 的原理

定位 new（placement-new）表达式

定义

格式

代码示例

经典题目

malloc / free 和 new / delete 的区别

共同点

不同点

内存泄漏

定义

核心原因

危害

总结