[C++系列] 38. 内存池与operator new、operator delete函数

1.operator new 和operator delete

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

operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

int main() {
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);

	// 1.malloc/calloc/realloc的区别是什么？
	int* p2 = (int*)calloc(2, sizeof(int));     // 申请元素个数   大小
	int* p3 = (int*)realloc(p2, 1);




	void Test2()
	{
		// 申请单个Test类型的对象
		Test* p1 = new Test;
		delete p1;

		// 申请10个Test类型的对象
		Test* p2 = new Test[10];
		delete[] p2;
	}

	/*
	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);   // 释放空间 dbg==debug

		__FINALLY
			_munlock(_HEAP_LOCK);  /* release other threads */
		__END_TRY_FINALLY

			return;
	}

	/*
	free的实现
	*/
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)


	system("pause");
	return 0;
}

 

重要： 

 内置类型：

new ---> operator new(malloc + 异常) 

delete ---> operator delete(free)

new[] ---> operator new[] ---> operator new(malloc + 异常) 

delete[] ---> operator delete[] ---> operator delete(free)

自定义类型：

new ---> operator new(malloc + 异常) ---> 构造

delete ---> 析构 ---> operator delete(free)

new[] ---> operator new[] ---> operator new(malloc + 异常) ---> 构造

delete[] ---> 析构 ---> operator delete[] ---> operator delete(free)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

对内置类型来讲，malloc与new唯一的区别为：new申请失败时会抛出异常，malloc申请失败时会返回指针空值。free与delete，delete相当于内部封装free，其它无区别。

对自定义类型来讲，new、delete除了申请和释放空间外，还会调用构造函数、析构函数，而malloc、free不会调用调用构造、析构函数进行初始化和资源清理工作。

内部调用过程都是一致的，new底层会调用operator new，operator new调用完毕后会调用构造函数。delete底层会调用operator delete，operator delete调用完毕后会调用析构函数。

[n]，相当于把new、delete又封装了一次，new[n]相当于调了n次operator new，也相当于调了n次构造函数。delete同理。

总结：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在释放空间前会调用析构函数完成空间中资源的清理
7. new/delete比malloc和free的效率稍微低点，因为new/delete的底层封装了malloc/free

2. 内存池

其中，针对于operator new、operator delete不需要自己去进行调用，用户只需要使用new、delete即可，new和delete会自动调用operator new 及 operator delete。一般情况下没有什么实质的作用，但也有些特殊的应用，如：内存池，如果自己想去定义当前类的内存申请、释放方式的话可以去重载operator new 和 operator delete。

以快递进行举例，若快递公司在各个省份都建有仓库，那么进行派货时就能够就近派货大大提高快递运输效率并降低运输成本。原生的new和delete每次申请空间时相当于从总部发货，而内存池就相当于这样一个仓库，其内存也是向系统申请的，现在相当于避免了舍近求远的额外开销，提高程序效率。

以带头双向循环链表举例：链表在每次进入一个节点时，需要new/malloc一次。那么现在有1000个节点的情况下，单单一行代码就需要向系统重复申请1000次？若是运行10+程序时，必然会导致程序加载运行缓慢，这当然不是我们希望看到的。我们在考虑数组的申请模式：数组每次申请一片内存，效率会比链表高很多。而对于链表来讲可以考虑添加内存池提高效率，每次链接内存池进行内存申请。

struct ListNode {
	ListNode(int data = 0)
		:_data(data)
		, _next(nullptr)
		, _prev(nullptr) {
		cout << "ListNode()" << endl;
	}
	void* operator new(size_t n) {
		cout << "operator new(size_t n）" << endl;
		void* p = allocator<ListNode>().allocate(1); // allocator相当于空间配置器，用其来分配内存，现可当做内存池来使用
							     // 数字1 表示ListNode结构体的大小，相当于从内存池拿出一个ListNode对象大小的空间出来
		return p;
	}
	ListNode* _next;
	ListNode* _prev;
	int _data;
};

class List {
public:
	List()
		:_head(new ListNode) {
		_head->_next = _head;
		_head->_prev = _head;
	}
private:
	ListNode* _head;
};




int main() {
	ListNode* _head;
	List list;          // 查看调用顺序
	system("pause");
	return 0;
}

先调用operator new（）再调用构造函数。在此原生的new是从系统直接进行内存申请，现在重载之后，直接从用户自定义重载函数下进行内存申请。把空间申请好之后在调用构造函数进行初始化。同样，定义了operator new也需要再自定义operator delete，即内存池加载的内存不能用free、delete进行释放，导致不匹配、不对称。

struct ListNode {
	ListNode(int data = 0)
		:_data(data)
		, _next(nullptr)
		, _prev(nullptr) {
		cout << "ListNode()" << endl;
	}
	void* operator new(size_t n) {
		// cout << "operator new(size_t n）" << endl;
		void* p = allocator<ListNode>().allocate(1); // allocator相当于空间配置器，用其来分配内存，现可当做内存池来使用
													 // 数字1 表示ListNode结构体的大小，相当于从内存池拿出一个ListNode对象大小的空间出来
		cout << "mem pool allocator" << endl;        // 申请完毕后打印 
		return p; 
	}
	void operator delete(void* p) {                  // 自定义operator delete 不会真正释放空间，而是将delete的空间又返还给内存池
		allocator<ListNode>().deallocate((ListNode*) p, 1);
		cout << "mem pool deallocator" << endl;
	}
	ListNode* _next;
	ListNode* _prev;
	int _data;
};

class List {
public:
	List()
		:_head(new ListNode) {
		_head->_next = _head;
		_head->_prev = _head;
	}
	~List() {
		if (_head) {       // 不能直接释放链表头结点，需要将后面的节点释放掉再去释放头节点
			ListNode* cur = _head->_next;
			while (cur != _head) {
				ListNode* next = cur->_next;
				delete cur;
				cur = next;
			}
			delete _head;
			_head = nullptr;
		}
	}
private:
	ListNode* _head;
};


int main() {
	ListNode* _head;
	List list;          // 查看调用顺序
	List l[20];	    // 从内存池分配20个空间出来，再将空间返还给内存池
	system("pause");
	return 0;
}

如果当前没有自定义operator new与operator delete时，其会调用系统的全局函数，即不会输出任何东西，再去执行时其任何不会进行输出。如果需要自定义当前类的内存申请和释放的方式时，需要对上面两个函数进行重载，即以自己的方式进行内存申请或释放，即可以采用内存池进行操作。由上面的场景：链表在申请1W个节点时，系统的全局函数需要执行1W次，而采用内存池进行''就近仓库发货''，自然可以大大提高效率。一般情况下不需要进行用户主动重载，在特殊场景下进行重载自定义使用。

并且重载函数过后不会对其它类产生影响，只针对当前类有效。

operator new 、operator delete是给new、delete这两个关键字定制的，用户不需要自行进行调用，new会自动调用operator new，delete会自动调用operator delete。即需要改变当前类的空间申请、释放的操作时，可以对operator new、operator delete进行重载，改变为自己想要的方式方法。