【C++】第六节—内存管理

【C++】第六节—内存管理

​

1. C/C++内存分配

程序运行过程中内存分区域，见下：

现在我们必须要清楚，写一个程序，程序里面的变量都放在我们刚才介绍的那个区域呢？见下题目（面试题，面试会考这样的题，那可得好好学清楚了）

【说明】

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

---

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

【可以回顾一下C语言里面的动态内存管理【C语言】动态内存管理-CSDN博客】

【面试题】

1. malloc/calloc/realloc的区别？
2. malloc的实现原理？ 【CTF】GLibc堆利用入门-机制介绍_哔哩哔哩_bilibili

---

3. C++内存管理方式

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

3.1 new/delete操作内置类型

代码语言：javascript代码运行次数：0运行复制

int main()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];

	int* ptr7 = new int[3] {1,2,3};
	int* ptr8 = new int[5] {1,2,3,4};

	delete ptr4;
	delete ptr5;
	delete[] ptr6;
	delete[] ptr7;
	delete[] ptr8;

	return 0;
}

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

我们调试看一下初始化的效果

C++以后就用new和delete，主要的区别在于自定义类型的使用

3.2 new和delete操作自定义类型

但是如果对于A类使用new去申请空间但是如果没有A的默认构造又不去传参调用就会报错，见下：

没有默认构造是不可以的，所以一个类还是要有构造函数为好！

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

总结一下，malloc/free和new/delete的区别，主要还是针对自定义类型，对于自定义类型会自动调用构造函数和析构函数，还有用法上面会更简单， 如果是new多个对象是多次调用构造函数和析构函数，记得用 。

代码语言：javascript代码运行次数：0运行复制

#include<stdlib.h>
#include<iostream>
using namespace std;

int main()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];

	int* ptr7 = new int[3] {1,2,3};
	int* ptr8 = new int[5] {1,2,3,4};

	delete ptr4;
	delete ptr5;
	delete[] ptr6;
	delete[] ptr7;
	delete[] ptr8;

	return 0;

}


class A
{
public:
	A(int a = 0)//构造函数
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()//析构函数
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
	//只申请空间
	A* p1 = (A*)malloc(sizeof(A));

	//申请空间+构造函数
	A* p2 = new A;
	A* p3 = new A(1);

	//释放空间
	free(p1);

	//析构函数+释放空间，这里面的析构函数是用来释放p2指向的类里面申请的空间，
	//释放空间指的是释放动态申请的p2指向的空间
	delete p2;
	delete p3;

	// 内置类型是几乎是一样的
	int* p10 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;

	free(p10);
	delete p4;

	A* p5 = (A*)malloc(sizeof(A) * 10);
	//这里会10次调用构造函数，对着10个对象依次初始化
	A* p6 = new A[10];//这里会调用默认构造,缺省值是0

	//我们可以对这些对象进行初始化
	//这是有名的参数
	A aa1(1);
	A aa2(1);
	A* p7 = new A[10]{aa1,aa2};//剩下的8个对象调用默认构造，没有默认构造就会报错

	//还可以使用匿名对象进行初始化
	A(2);
	A(2);
	A* p8 = new A[10]{A(2),A(2)};

	//或者直接用隐式类型转换
	A* p9 = new A[10]{ 33,44 };//对于隐式类型转换必须有相应的构造函数，不然不可以

	free(p5);
	//10次调用析构函数
	delete[] p6;
	delete[] p7;
	delete[] p8;
	delete[] p9;

	return 0;
}

在下面的场景中自定义类型用new要比C语言更方便简洁

代码语言：javascript代码运行次数：0运行复制

#include<iostream>
using namespace std;

struct ListNode
{
	int _val;
	ListNode* _next;

	//构造函数
	ListNode(int val)
		:_val(val)
		,_next(nullptr)
	{}
};

int main()
{
	//不需要像C语言那样要BuyNode，这里直接new对象同时还能调用构造函数
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	ListNode* n4 = new ListNode(4);
	n1->_next = n2;
	n2->_next = n3;
	n3->_next = n4;

	delete n1;
	delete n2;
	delete n3;
	delete n4;

	return 0;
}

---

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不是运算符new和delete的重载，是全局的库里面的一个函数）

代码语言：javascript代码运行次数：0运行复制

/*
operator new：该函数实际通过malloc来申请空间（对malloc的一个封装）
当malloc申请空间成功时直接返回；
申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
//相较于malloc是直接退出
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	// try to allocate size bytes
	void* p;
	//这里malloc一块空间，将申请空间空间的地址给p，p不为0就跳出循环了也就是申请空间成功了
	while ((p = malloc(size)) == 0)
		if (_callnewh(size) == 0)
		{
			// report no memory
			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常（后面会学，异常是C++处理错误的一种方式）
			static const std::bad_alloc nomem;
			_RAISE(nomem);
		}
	return (p);
}

/*
operator delete: （该函数其实就是对free的封装）该函数最终是通过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);//我们可以看到下面有一个宏定义，_free_dbg其实就是free(p)
	__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的实现原理

5.1 内置类型

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

5.2 自定义类型

下面我们调试转到反汇编看底层的指令

代码语言：javascript代码运行次数：0运行复制

class A
{
public:
	A(int a = 0)//构造函数
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()//析构函数
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	//new是申请空间+构造函数
	//调用operator new函数，相较于原来的malloc，C++对于申请空间失败会抛出异常，malloc只会返回空指针
	//其实代码执行后本质上就是调用指令，我们来调试看一下代码背后的指令
	A* a1 = new A(10);
	A* a2 = new A;

	delete a1;
	delete a2;

	return 0;
}

• new的原理

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

• delete的原理

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

• new TN的原理

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

再进去之后还是调用operator new

• delete[]的原理

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

• 关于抛出异常

我们前面讲过在VS编译器X86（32位）（在X64（64位）下进程地址空间就会大很多，要想达到下面的效果还要申请更大的空间）堆大概有不到2G的内存空间，下面我们来尝试申请很大的空间让内存申请失败。（32位下进程地址空间是2^32，也就是4GB，64位下进程地址空间是2^64，可想而知，很大很大，那么堆也就很大了，想申请很大的空间让空间申请失败还是很难的）

内存申请失败程序直接就停止了

我们在代码里面进行捕获异常，详细内容后面会介绍，我们先了解一下

这个异常的机制是operator new抛出来的，我们在上面的operator new函数里面也看到了如果空间申请失败会出现抛出异常的操作，会直接跳到catch的地方去，p5后面的代码都不会再执行

new底层是调用operator new函数和构造函数。那为什么不直接使用malloc来直接开空间呢？ 因为malloc开空间失败是返回0/nullptr，而调用operator new开空间失败是抛异常，这就是封装的意义，更符合当C++出现错误时处理的一种方式

代码语言：javascript代码运行次数：0运行复制

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

	int* p2 = new int[1024 * 1024 * 100];
	cout << p2 << endl;

	int* p3 = new int[1024 * 1024 * 100];
	cout << p3 << endl;

	int* p4 = new int[1024 * 1024 * 100];
	cout << p4 << endl;

	int* p5 = new int[1024 * 1024 * 100];
	cout << p5 << endl;

    //出了Func函数对象对自动调用析构函数，而且new的对象里面我们没有额外申请空间
    //所以我们就不用显示delete了
}

int main()
{
	try
	{
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	Func();

	return 0;
}

还有一点，见下面代码里面的解释

代码语言：javascript代码运行次数：0运行复制

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

	int* p2 = new int[1024 * 1024 * 100];
	cout << p2 << endl;

	int* p3 = new int[1024 * 1024 * 100];
	cout << p3 << endl;

	int* p4 = new int[1024 * 1024 * 100];
	cout << p4 << endl;

	int* p5 = new int[1024 * 1024 * 100];
	cout << p5 << endl;
}

int main()
{
	try
	{
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	Func();

	//我们可以直接使用operator new，这是一个全局的库里面的函数可以直接调用
	//它的返回值是void* ，需要去强转一下，这个函数如果申请空间失败的话会直接抛出异常不需要我们去检查p1
	//operator new和new不一样的是它不去调用构造函数，所以operator new相当于new两部分中的一部分对于自定义类型而言
	A* p1 = (A*)operator new(sizeof(A));
	// 不支持
	//p1->A(1);
	new(p1)A(10);

	p1->~A();
	operator delete(p1);

	return 0;
}

---

6. 定位new表达式(placement-new) （了解）

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

使用格式：

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

使用场景：

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

代码语言：javascript代码运行次数：0运行复制

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

// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));

	//C++不支持这样显示调用构造函数
	//p1->A();

	A* p2 = (A*)operator new(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参

	//可以显示调用析构函数
	p1->~A();
	free(p1);

	//这里的两句代码就相当于new
	A* p2 = (A*)operator new(sizeof(A));//相当于new里面的开空间
	new(p2)A(10);//相当于new里面的构造函数

	//这里相当于delete
	p2->~A();
	operator delete(p2);

	return 0;
}

（简单了解一下内存池）

---

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

（前四点是从用法出发，后两点是从功能出发）

【注意】

代码语言：javascript代码运行次数：0运行复制

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
		delete _p;//这里是释放_p动态内存的空间
	}
private:
	int _a;
	int* _p = new int;//为_p动态申请一块空间
};

int main()
{
	//这是正常的使用operator new和operator delete
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);

	p2->~A();
	operator delete(p2);

	// 1、不要忘记释放
	// 2、不要交错使用
	
	A* p1 = (A*)operator new(sizeof(A));//1.只是开了空间没有去初始化，_p里面是随机值
	delete p1;//2.先调用析构函数，再调用operator delete

	A* p3 = new A;
	delete p3;
  
	// 内存泄漏（程序不会崩溃，不管怎么样还是配套的去使用刚才讲的那些）
	//A* p1 = new A;
	//free(p1);//没有去释放p1里面动态申请的内存

	return 0;
}

OK，本节关于C++内存管理的知识就结束了，下节课我们开启模版，STL的学习。（博客写起来真的很慢）

完——

本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。 原始发表：2025-03-30，如有侵权请联系 cloudcommunity@tencent 删除前往查看异常c++对象函数内存管理