C/C++内存管理

系列文章目录

---

一、C/C++内存分布

当C/C++程序运行起来时，每个进程（正在运行的程序的一种抽象）看到的内存是一致的，就好像每个进程都在独占的使用主存一样，称为虚拟地址空间。如下：

我们从下向上依次介绍：
代码段：

代码段存放可执行代码和只读常量。

数据段：

数据段存放全局变量和static修饰的静态数据。

运行时堆：

相较于程序一开始运行就被指定了大小的代码段和数据段不同，堆可以在运行时进行动态的扩展和收缩。而动态内存分配的空间都在堆上。同时，堆上的空间是自下而上分配的。

共享库：

大约在虚拟地址空间中间部分是一块用来存放像C标准库和数学库这样的共享代码和数据区域。

用户栈：

再往上就是用户栈，编译器用它来实现函数调用。因为函数调用时的函数栈帧都是在栈上开辟的。和堆一样，用户栈在程序的执行期间可以动态的扩展和收缩。每当我们调用一个函数时，栈就会增长；从一个函数返回，栈就会收缩。栈是向下增长的。

内核虚拟内存：

虚拟空间顶部的区域是为内核保留的。不允许程序读写这个区域的内容或者直接调用内核代码定义的函数。它们必须通过调用内核来执行这些操作。

二、C++内存管理方式

首先，在C语言中，可以通过malloc、calloc和realloc来动态分配内存，通过free释放内存。而malloc和calloc的区别就在于，calloc分配空间之后会将空间初始化为0。而realloc有两种分配方式，原地或者异地。当原地的空间足够我们扩大，就会在原地扩，否在就在异地扩。如果有需要详细了解，请参见：动态内存分配

C语言的内存管理方式在C++中也同样适用，但是有些地方会无能为力或使用起来比较麻烦，因此C++推出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

2.1 对于内置类型

int main()
{
	//动态申请一个整型的空间
	int* ptr1 = new int;

	//动态申请一个整型的空间并初始化为10
	int* ptr2 = new int(10);

	//动态申请10个整型空间
	int* ptr3 = new int[10];

	delete ptr1;
	delete ptr2;
	delete[] ptr3;

	return 0;
}

注意：申请和释放单个元素的空间，使用new和delete，申请和释放连续的空间，使用new[]和delete[]。

2.2 对于自定义类型

先来看一段代码：

class Test
{
public:
	Test()
		: _data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _data;
};


void Test1()
{
	//申请单个Test空间
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);
	//申请十个Test空间
	Test* p2 = (Test*)malloc(sizeof(Test) * 10);
	free(p2);

	Test* p3 = new Test;
	delete p3;
	Test* p4 = new Test[10];
	delete[] p4;
}

结果如下：

可以看出malloc，free和new和delete的区别，在申请自定义类型的空间时，new会调用默认构造函数，delete会调用析构函数，而malloc和free不会。

三、operator new与operator delete函数

3.1 operator new与operator 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)

其实oerator new实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛出异常。同样的，operator delete最终也是通过free来释放空间的。

3.2 operator new与operator delete的类专属重载。

下面代码演示了，针对链表节点的ListNode通过类专属重载operator new与operator delete，实现了链表结点使用内存池申请和释放内存，提高效率。

代码如下：

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;
	void* operator new(size_t n)
	{
		void* p = nullptr;
		p = allocator<ListNode>().allocate(1);
		cout << "memory pool allocate" << endl;
		return p;
	}
	void operator delete(void* p)
	{
		allocator<ListNode>().deallocate((ListNode*)p, 1);
		cout << "memory pool deallocate" << endl;
	}
};
class List
{
public:
	List()
	{
		_head = new ListNode;
		_head->_next = _head;
		_head->_prev = _head;
	}
	~List()
	{
		ListNode* cur = _head->_next;
		while (cur != _head)
		{
			ListNode* next = cur->_next;
			delete cur;
			cur = next;
		}
		delete _head;
		_head = nullptr;
	}
private:
	ListNode* _head;
};

以往我们申请空间，每次都要像系统申请，但是这样似乎太麻烦，为了使效率提高，我们可以先申请较大的一块空间留作备用，需要时在这块空间中取就可以了。这就是内存池技术。

四、new和delete的实现原理。

4.1 内置类型

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

4.2 自定义类型

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

五、定位new表达式（placement-new）

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

使用格式：

new(place_addreee) type或者new(place_address) type(Initializer-list)

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

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

六、malloc/free和new/delete的区别

二者的共同点是：都是从堆上申请空间，都需要用户手动释放。

不同点是：

1. malloc/free是函数，而new/delete是操作符。
2. malloc申请的空间不会初始化，而new申请的空间会调用构造函数初始化。
3. malloc申请空间时，需要手动计算空间大小，而new申请空间只需跟上类型即可。
4. malloc返回值为void*，使用时要进行强制类型转换，而new不需要，因为其后跟的是空间的类型。
5. malloc申请空间失败时会返回NULL，而new申请空间失败时会抛出异常。
6. 申请自定义类型空间时，malloc/free只会申请空间和释放空间，而不会调用构造函数和析构函数，而new在申请空间后会调用构造函数初始化，而delete在释放空间前会调用析构函数进行空间中资源的清理。

七、内存泄漏

7.1 什么是内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

长期运行的程序出现内存泄漏影响很大，如操作系统、后台服务等，出现内存泄漏会导致响应越来越慢，最终卡死。

7.2 内存泄漏的分类

堆内存泄露：

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄露：

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

7.3 如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。