【探寻C++之旅】第四章：内存管理

今天，我们继续踏入追寻C++的冒险历程。上一章我们简单介绍并且了解了C++中的类和对象，那么本章将为大家讲解C++中另一重要的部分：内存管理。下面让我们一起来进入内存管理的学习。

1. C和C++的内存分布

在我们的程序运行时的内存会分为几个区域，如下图所示：

QQ20250217-231648

在上图中，当前阶段我们需要了解的只有四个，分别是栈、堆、静态区、和常量区。

• 栈：又叫堆栈，主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等，栈是向下增长的。
• 堆：程序运行时动态内存分配是在堆上，堆是可以上增长的。
• 静态区：存储全局数据和静态数据。
• 常量区：可执行的代码/只读常量。

下面这张图可以让大家更好得去理解程序中各内存各区域的分配：

QQ20250218-202413

在堆中我们所开辟的每一块空间都是按照类似链表的结构进行链接的，因此当我们对开辟的空间进行越界访问并修改其中的值，我们有可能会改变了指向下一个地址的指针，此时编译时编译器会发生段错误。

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

我们先简单回顾一下在C语言中动态开辟空间（都是在堆上开辟的空间）的几种方式：

• malloc函数：void* malloc (size_t size); 这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针。 该函数的参数只有一个，就是我们需要开辟空间的大小（单位为字节）。开辟成功，则返回⼀个指向开辟好空间的指针，失败则返回一个空指针，因此在使用malloc时一定要注意检查返回值。返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定（强转返回值即可）。
• calloc函数：void* calloc (size_t num, size_t size); 该函数与malloc一样，也⽤来动态内存分配。函数的具体功能是为num个⼤⼩为 size 的元素动态开辟⼀块空间，并且把空间的每个字节初始化为0。 malloc与calloc： ​ 两者同样是动态开辟空间，但是不同点在于calloc将开辟的空间的每个字节都初始化为0，而malloc则全为随机值。
• realloc函数：void* realloc (void* ptr, size_t size); 该函数可以对动态开辟的空间的⼤⼩进行调整。第一个参数ptr是要调整的内存地址，第二个参数size是调整之后的新大小，返回值为调整之后的内存起始位置。在调整原内存空间⼤⼩的基础上，还会将原来内存中的数据移动到新的空间。 realloc在调整内存空间的是存在两种情况：
  • 情况1：原有空间之后有⾜够⼤的空间。要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发⽣变化。
  • 情况2：原有空间之后没有⾜够⼤的空间。在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。这样函数返回的是⼀个新的内存地址。
• free函数：void free (void* ptr); 该函数是⽤来释放动态开辟的内存。如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的。如果参数 ptr 是NULL指针，则函数什么事都不做。

忘记释放不再使⽤的动态开辟的空间会造成内存泄漏。 切记：动态开辟的空间⼀定要释放，并且正确释放。

3. C++内存管理方式

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

其中new和delete是两个操作符，用于动态开辟空间和释放空间。

3.1 new/delete操作内置类型

直接看下面的代码：

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

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

3.2 new/delete操作自定义类型

看下面的代码：

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(1);
	free(p1);
	delete p2;
    
	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;
    
	A* p5 = (A*)malloc(sizeof(A)*10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;
}

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

3.3 operator new与operaotr delete函数

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

来看一下稍微它们的底层代码：

/*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 */
		_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.4 new与delete的实现原理

对于内置类型：

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

对于自定义类型：

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

3.5 定位new表达式（了解即可）

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

• 使用格式：new (place_address) type或者new (place_address) type(initializer-list) 。place_address必须是一个指针，initializer-list是类型的初始化列表
• 使用场景：定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

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

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

尾声

若有纰漏或不足之处欢迎大家在评论区留言或者私信，同时也欢迎各位一起探讨学习。感谢您的观看！