C++ 内存管理

Fuyo_11192026-04-28 17:43

C++内存管理

  • [1. C++内存分布](#1. C++内存分布)
  • [2. C++内存管理方式](#2. C++内存管理方式)
    • [2.1 new/delete 操作内置类型](#2.1 new/delete 操作内置类型)
    • [2.2 new和delete 操作自定义类型](#2.2 new和delete 操作自定义类型)
  • [3. 若new申请内存失败了，如何处理？](#3. 若new申请内存失败了，如何处理？)
  • [4. operator new与operator delete](#4. operator new与operator delete)
    • [4.1 operator new与operator delete函数（重点📌）](#4.1 operator new与operator delete函数（重点📌）)
  • [5. new 和 delete 的实现原理](#5. new 和 delete 的实现原理)
    • [5.1 内置类型](#5.1 内置类型)
    • [5.2 自定义类型](#5.2 自定义类型)
    • [5.3 面试题常考👔](#5.3 面试题常考👔)
    • [5.4 使用结论](#5.4 使用结论)
  • [6. 定位new表达式（placement-new）](#6. 定位new表达式（placement-new）)
  • [7. malloc/free 和 new/delete 的共同点](#7. malloc/free 和 new/delete 的共同点)
  • [8. malloc/free 和 new/delete 的区别](#8. malloc/free 和 new/delete 的区别)

1. C++内存分布

一个数据的存储是需要分区（分段）的，分区，其实分的就是生命周期。

函数调用建立栈帧，栈帧就放在栈这个区域。

动态申请的数据放在堆中

全局数据，静态数据放在数据段

常量定义在代码段

我们先来看下面的一段代码和相关问题。

cpp 复制代码 
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";// 开5个字节
	const char* pChar3 = "abcd";//开5个字节 
	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. 选择题
cpp 复制代码 
选项：A.栈    B.堆   C.数据段（静态区）    D.代码段（常量区）
globalvar在哪里？C 
staticGlobalvar在哪里？C 
staticVar在哪里？  C
localvar在哪里？  A
num1在哪里？ A

char2在哪里？A    
*char2在哪里？A
pChar3在哪里？A
*pChar3在哪里？D
ptr1在哪里？A  
*ptr1 在哪里？B

*char2 指向首元素地址，也就是指向A，因此，它位于栈中
const char* pChar3 中const修饰的是*pChar3 这个值，并非pChar3这个地址（指针）本身

ptr1是一个指针，是指向首元素的指针，因此，它也在栈上

*ptr1 是ptr1指向的内容

说明：

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

2. C++内存管理方式

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

2.1 new/delete 操作内置类型

📃代码演示new 和 delete 是如何操作内置类型的

cpp 复制代码 
int main()
{
	// 动态申请空间
	// 申请 1个 int型的空间
	int* p1 = new int;
	
	// 申请 10个 int型的空间
	int* p2 = new int[10];

	// 不用了就delete
	delete p1;
	delete[] p2;

	// 初始化
	int* p3 = new int(1);// 初始化为1
	int* p4 = new int[10] {0};// 全部初始化为0
	int* p5 = new int[10] {1, 2, 3, 4};// 除了指定初始化的部分，其他均为0

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

	return 0;
}

🚨注意：

  • 申请和释放单个元素的空间，使用 new 和 delete 操作符；
  • 申请和释放连续的空间，使用 new[] 和 delete[] 。
  • 二者需要匹配使用。

2.2 new和delete 操作自定义类型

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

这就是 new 和delete 与 malloc 和free 最大的区别。

📃自定义类型A的代码：

cpp 复制代码 
class A
{
public:
	A(int a1 = 1, int a2 = 0)
		:_a1(a1)
		,_a2(a2)
	{
		cout << "A(int a)" << endl;
	}

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

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}

		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	void Print()
	{
		cout << "A::Print->" << _a1 << endl;
	}

private:
	int _a1;
	int _a2;
};

👔有默认构造（无需显式传参时）的代码演示：

cpp 复制代码 
int main()
{
	A* p1 = new A;
	A* p2 = new A(2, 2);
	
	// 申请3个数据类型为A的空间（调用三次默认构造）
	A* p3 = new A[3];
}

👔申请多个数据类型为A的空间，并显式初始化的方法：

  1. 先单独构造并初始化A类型的变量，再将其作为数据调用拷贝构造（不推荐❌️，复杂且麻烦，编译器还无法做出优化）
cpp 复制代码 
A aa1(1, 1);
A aa2(2, 2);
A aa3(3, 3);

A* p4 = new A[3]{ aa1,aa2,aa3 };//调用拷贝构造
  1. 使用匿名对象
cpp 复制代码 
A* p4 = new A[3]{ A(1,1),A(2,2),A(3,3) };// 使用匿名对象
// 编译器优化后 -> 直接构造
  1. 隐式类型转换
cpp 复制代码 
A* p5 = new A[3]{ {1,1},{2,2},{3,3} };// 隐式类型转换
//编译器优化后 -> 直接构造

💡建议：往后申请内存时，不管是内置类型，还是自定义类型，都使用new 和delete

3. 若new申请内存失败了，如何处理？

我们可以发现，new和malloc 之间还有一个区别：

先前，利用malloc申请空间时，失败时，我们需要显式判空，判断内存是否申请成功，而在new 中，我们并没有这么做，这是为什么呢？

💡原因：

  • malloc 申请空间失败，就会返回空指针，程序并不会报错而是继续执行，不判断直接使用会导致程序崩溃，且难以定位错误。
  • new 申请内存失败默认直接抛异常，程序直接终止 / 可捕获。

🤔若new申请内存失败了，如何处理？

new 申请空间失败，会抛异常，我们可以利用try - catch 捕获它。

📃演示代码如下：

  • try - catch 可以捕获申请大块内存失败时的抛异常。
cpp 复制代码 
try 
{
	void* p1 = new char[1024 * 1024 * 1024];
	void* p2 = new char[1024 * 1024 * 1024];
	void* p3 = new char[1024 * 1024 * 1024];
}
catch (const exception& e)// 捕获
{
	// 获取发生的异常
	cout << e.what() << endl;
	// what - 发生了什么？我来告诉你
	// 若空间开辟失败，则会显示：bad allocation
}

what 的作用是打印错误信息

  • 也可以捕获调用的【函数内部】的抛异常
cpp 复制代码 
void func()
{
	void* p1 = new char[1024 * 1024 * 1024];
	void* p2 = new char[1024 * 1024 * 1024];
	void* p3 = new char[1024 * 1024 * 1024];
}

int main()
{
	try 
	{
		func();
	}
	catch (const exception& e)// 捕获
	{
		// 获取发生的异常
		cout << e.what() << endl;
		// what - 发生了什么？我来告诉你
		// 若空间开辟失败，则会显示：bad allocation
	}

	return 0;
}

⭐通过调试，我们可以发现，一旦失败，程序便会直接跳转到catch 处，catch 后的程序继续走，让程序正常执行结束。

4. operator new与operator delete

4.1 operator new与operator delete函数（重点📌）

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

📃operator new 和operator delete 的实现

cpp 复制代码 
/*
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);
}
}
/*
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 来释放空间的。

5. new 和 delete 的实现原理

实际上，new 和delete 并不是另外再造一套专门的机制来开空间 / 释放空间的，而是以malloc和free为底层进行改进后的升级版。

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[N] 的原理：

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

  • ⭐delete[N] 的原理：

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

5.3 面试题常考👔

  1. 看下列代码，是否会编译报错、运行崩溃❓️：
cpp 复制代码 
int main()
{
	int* p1 = new int[10];
	delete p1;			

	return 0;
}

⭐答：不会。
📃原因：new的底层是malloc ，delete 的底层是free，因此并不会报错。

哪怕把delete p1 ，改成了free(p1) ，都不会报错。

  1. 对比下列代码，p2 ，p3是否会编译报错、运行崩溃❓️：
cpp 复制代码 
class B
{
private :
	int _b1 = 2;
	int _b2 = 2;
};

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

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

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}

		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	void Print()
	{
		cout << "A::Print->" << _a1 << endl;
	}

private:
	int _a1 = 1;
	int _a2 = 1;
};


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

	A* p3 = new A[10];
	delete p1;
	return 0;
}

⭐ 答：p2 不会报错，但是p3会。
🔎探究过程：

通过反汇编，我们可以发现，10个B对象申请了80个字节，而10个A对象却申请了84个字节，这是为什么呢？

当我们开多个对象时，会在头上多申请4个字节，这4个字节用于存储对象的个数 ，给delete[] 用的

严格来讲，A和B都应该开4个字节存储对象个数，B没开这4个字节，是因为编译器优化了。

B没有写析构函数，B没有什么资源需要释放，编译器干脆就不调用析构函数，也就没开这4个字节。
📃总结原因：

delete针对new，于是就不管A头上的4个字节

调用free，也是从p3这个位置开始

但是，申请空间时，是从头上这个位置开始的

释放空间时，不能从中间开始释放！

因此，程序报错
示意图如下：

📌注：若程序出现异常终止，一般都是内存问题。

5.4 使用结论

使用结论：一定要匹配使用，不要错配。

6. 定位new表达式（placement-new）

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

🔧使用格式：
new(place_address)type 或者 new(place_address)type(initializer-list)

  • place_address 必须是一个指针
  • initializer-list 是类型的初始化列表

若使用operator new来申请内存：

  • 构造函数：不能像普通成员函数那样直接调用，只能通过定位new调用。
  • 析构函数：允许被显式调用。

注：构造函数，只能通过以下方式被调用

  • 对象定义
  • 普通new
  • 定位new

🔎new / delete 与 operator new / operator delete 的使用对比：

cpp 复制代码 
int main()
{
	A* p1 = new A(1);
	delete p1;

	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(1);// 利用定位new手动调用构造函数来初始化

	p2->~A();// 需要先调用析构函数（可显式调用析构）
	operator delete(p2);

	return 0;
}

⭐定位new的用途：若我们做了一个内存池（或多个），用来高频申请释放内存块，此时，并不是直接在堆上申请空间，此时若想对其进行初始化（调用构造函数），就需要利用定位new。

7. malloc/free 和 new/delete 的共同点

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

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

总结：C++中推荐使用new和delete来申请空间/释放空间

相关推荐
柳鲲鹏2 小时前
李善兰和牛顿，谁剽窃谁的运动三定律
笔记
澈2072 小时前
C++面向对象：类与对象核心解析
c++·算法
6Hzlia2 小时前
【Hot 100 刷题计划】 LeetCode 141. 环形链表 | C++ 哈希表直觉解法
c++·leetcode·链表
handler013 小时前
Linux 进程探索：从 PCB 管理到 fork() 的写时拷贝
linux·c语言·c++·笔记·学习
xuhaoyu_cpp_java3 小时前
MyBatis学习(五)
经验分享·笔记·学习·mybatis
众少成多积小致巨4 小时前
GNU Make 核心指南
android·c++
AI_661465974 小时前
副业平台收益效率评估：实验设计、指标体系与数据分析框架
经验分享·笔记
谭欣辰4 小时前
详细讲解 C++ 状压 DP
开发语言·c++·动态规划
阿星_4 小时前
Windows Subsystem for Linux (WSL) 运行 Firefox 浏览器时遇到中文乱码的解决方法
笔记
热门推荐
01GitHub 镜像站点02近期有什么ai的新消息，新动态？ 2026.4月032026年4月AI大事件深度解读：大模型竞争进入“深水区“04Codex 接入 DeepSeek API 完整配置文档052026年AI编程工具终极横评：Cursor vs Claude Code vs Copilot06零基础教你claude code 接入 deepseek V407在Windows 11上安装Docker的踩坑记录082026年AI前瞻：量子AI、具身智能与科学发现的新纪元09codex app每次打开重连5次Reconnecting问题解决10DeepSeek V4 全面解析：测评、对比、案例及实操指南