【C++】内存管理

William_wL_2025-11-06 22:56

文章目录

  • [1. C/C++内存分布](#1. C/C++内存分布)
  • [2. C++内存管理方式](#2. C++内存管理方式)
    • [2.1 new / delete操作内置类型](#2.1 new / delete操作内置类型)
    • [2.2 new / delete操作自定义类型](#2.2 new / delete操作自定义类型)
  • [3. operator new与operator delete函数](#3. operator new与operator delete函数)
  • [4. new和delete的实现原理](#4. new和delete的实现原理)
    • [4.1 内置类型](#4.1 内置类型)
    • [4.2 自定义类型](#4.2 自定义类型)
  • [5. 匹配使用](#5. 匹配使用)
  • [6. 定位new表达式（placement-new）](#6. 定位new表达式（placement-new）)
  • [7. malloc/free 和 new/delete 的区别](#7. malloc/free 和 new/delete 的区别)

1. C/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";
	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);
}

选项：A. 栈 B.堆 C.数据段（静态区） D.代码段（常量区）

  1. globalVar在哪里？
  2. staticGlobalVar在哪里？
  3. staticVar在哪里？
  4. localVar在哪里？
  5. num1在哪里？
  6. char2在哪里？
  7. *char2在哪里？
  8. pChar3在哪里？
  9. *pChar3在哪里？
  10. ptr1在哪里？
  11. *ptr1在哪里？

前五个是比较简单的：CCCAA

后面的我们来一起好好分析：

由上图可知：后面的选项就是AAADAB。

下面有几个点我们得分得很清楚：

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

2. C++内存管理方式

2.1 new / delete操作内置类型

cpp 复制代码 
#include<iostream>
using namespace std;

int main()
{
	//申请一个int对象
	int* p1 = new int;

	delete p1;

	//申请十个int对象
	int* p2 = new int[10];

	delete[]p2;
	return 0;
}

我们先来感受一下最基本的用法，首先new是不需要计算大小的，之间加上类型就可以，如果要申请多个对象就写[]，需要注意的是new要跟delete配套使用，如果是new多个对象使用了[]的话，那么delete的时候也需要加[]。针对这个配套使用我们下面还会说。那如果我想把申请的空间初始化呢？

cpp 复制代码 
#include<iostream>
using namespace std;

int main()
{
	//初始化
	int* p3 = new int(0);
	delete p3;

	int* p4 = new int[10] {0};
	delete[]p4;

	int* p5 = new int[10] {1, 2, 3, 4};
	delete[]p5;
	return 0;
}

申请一个对象时初始化就是在后面加个（），对于多个对象的初始化跟数组的初始化很像，比如p4，就是把十个对象都初始化为0，而p5则是把前4个对象初始化为1，2，3，4，后面的对象全初始化为0。
到目前为止，new / delete的功能确实比malloc /

free好用一点，但是也没有特别明显的优势啊，那么接下来我们就来看看祖师爷设计new / delete的厉害之处。

2.2 new / delete操作自定义类型

cpp 复制代码 
#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));
	cout << "##########" << endl;
	A* p2 = new A;
	free(p1);
	delete p2;

	return 0;
}

很明显，new在申请空间的时候调用了构造函数和析构函数，这就是new的最本质的区别了，这是malloc做不到的。下面我们继续来看一段代码，加深理解而且会跟前面的知识结合起来。

cpp 复制代码 
#include<iostream>
using namespace std;

class A
{
public:
	A(int a, int b = 0)
		:_a(a)
		,_b(b)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
	int _b;
};
int main()
{
	A* p1 = new A(1);
	A* p2 = new A(2, 2);

	A aa1(1, 1);
	A aa2(2, 2);
	A aa3(3, 3);
	A* p3 = new A[3]{ aa1,aa2,aa3 };

	//匿名对象
	A* p4 = new A[3]{ A(1,1),A(2,2),A(3,3) };

	//类型转换
	//A aa = { 1, 1 };
	A* p5 = new A[3]{ {1,1},{2,2},{3,3} };
	return 0;
}

这里面就用了匿名对象和隐式类型转换，不清楚的朋友可以去看一下我前面的博客>>>>>点击查看【C++】类和对象（下）
再说个点，我们之前malloc用完是需要再检查一下有没有失败，那new这里为啥没检查呢？这里需要引入一个抛异常的概念，我们以后再详细说，这里就先了解一下。

cpp 复制代码 
#include<iostream>
using namespace std;

int main()
{
	void* p1 = new char[1024 * 1024 * 1024];
	cout << p1 << endl;

	void* p2 = new char[1024 * 1024 * 1024];
	cout << p2 << endl;

	void* p3 = new char[1024 * 1024 * 1024];
	cout << p3 << endl;
	return 0;
}

3. operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过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);
		}
	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 */PE_IS_VALID(pHead->nBlockUse));
	_ASSERTE(_BLOCK_TY
	_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 自定义类型

  1. new的原理

1）调用operator new函数申请空间。

2）在申请的空间上执行构造函数，完成对象的构造。

cpp 复制代码 
#include<iostream>
using namespace std;

class A
{
public:
	A(int a, int b = 0)
		:_a(a)
		,_b(b)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
	int _b;
};

int main()
{
	A* p1 = new A(1);
	delete p1；
	return 0;
}
  1. delete的原理

1）在空间上执行析构函数，完成对象中资源的清理工作。

2）调用operator delete函数释放对象的空间。

  1. new T[]的原理

1）调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请。

2）在申请的空间上执行N次构造函数。

  1. delete[]的原理

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

5. 匹配使用

new / delete， malloc / free， new[] / delete[]

这些都是要匹配使用的，如果不匹配使用的话可能就会出现各种问题。

cpp 复制代码 
#include<iostream>
using namespace std;

int main()
{
	int* p1 = new int;
	free(p1);
	return 0;
}

如果我们这样写代码会发生什么呢？

我们运行一下，发现不会编译错误也不会程序崩溃，那有没有内存泄漏呢？这里就直接说了，是没有内存泄漏的，因为这是内置类型，只需要开空间就行，而开空间调用的是operator new，这里如果要释放则需要调_free_dbg，而直接用free也会调用_free_dbg，所以没有内存泄漏。但是我们也不要这样写。那如果我们这里不是int，而是A类型的话，这里就会少调用一次析构函数，那再如果A的析构函数释放了一些资源的话，那就会出现内存泄漏了。
同理，即使这里不是new一个对象，而是new[]，如果是内置类型用free的话，问题也不是很大，但是如果是自定义类型，那就问题大了。而且别说用free了，用delete问题都很大。

cpp 复制代码 
#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0, int b = 0)
		:_a(a)
		,_b(b)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
	int _b;
};
int main()
{
	A* p1 = new A[10];
	delete p1;
	return 0;
}

这里怎么就崩溃了呢？下面我们来探讨一下。

首先我们要申请多少空间呢？显然是80个字节。那我们去汇编里面看看

咦？这里为什么是84个字节呢，这4个字节哪里来的？

所以这里多开了4个字节的空间来存对象的个数，所以我们delete[]的时候会偏移4个字节再释放，而我们这里如果用delete的话就相当于从半截开始释放了，这样是不允许的。
但是我们如果写内置类型或者一部分自定义类型的时候是不报错的，这是为什么呢？这就跟编译器的优化有关系了，因为编译器没有发现上述所说的对象的析构函数，所以不会多开空间去存对象的个数。
上面的那么多字，其实就讲了一件事：一定要匹配使用！！！！

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

这一块现在对我们来说了解一下就可以。

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

使用格式：

new（place_address）type或者new（place_address）type（initializer-list）

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

使用场景：

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

7. 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在释放空间前会调用析构函数完成空间中资源的清理释放。
相关推荐
星星火柴9363 小时前
笔记 | C++面向对象高级开发
开发语言·c++·笔记·学习
悲伤小伞3 小时前
Linux_Socket_UDP
linux·服务器·网络·c++·网络协议·udp
八个程序员4 小时前
自定义函数（C++）
开发语言·c++·算法
微露清风5 小时前
系统性学习C++-第十讲-stack 和 quene
java·c++·学习
报错小能手5 小时前
C++笔记（面向对象）静态联编和动态联编
开发语言·c++·算法
WBluuue5 小时前
AtCoder Beginner Contest 430(ABCDEF)
c++·算法
Elias不吃糖5 小时前
第四天学习总结：C++ 文件系统 × Linux 自动化 × Makefile 工程化
linux·c++·学习
沐怡旸6 小时前
【穿越Effective C++】条款14：在资源管理类中小心copying行为——RAII类的拷贝语义设计
c++·面试
AA陈超6 小时前
虚幻引擎5 GAS开发俯视角RPG游戏 P07-06 能力输入的回调
c++·游戏·ue5·游戏引擎·虚幻
热门推荐
01GitHub 镜像站点02综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件03UV安装并设置国内源04npm使用国内淘宝镜像的方法05Linux下V2Ray安装配置指南06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07BongoCat - 跨平台键盘猫动画工具08《大数据技术原理与应用》实验报告三 熟悉HBase常用操作09NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南10GitLab 零基础入门指南：从安装到项目管理全流程