【面经总结c/c++】你了解内存池的设计思想吗？

内存池是什么？内存池是一组资源的集合。程序在申请堆上的内存时，我们可以给它一大块内存（远超出程序要申请的大小，即内存池），并且自己管理，而不是它要多少就从切换到内核态，给它多少。

为什么要设计内存池？两个原因：

1.因为频繁的new/delete 用户态转内核态，效率低：因为物理内存是一个物理硬件，程序要从物理硬件上申请资源，要调用系统调用，要切换到内核态，还调用驱动······一系列操作；

2.频繁的new/delete可能造成内存碎片。
如何设计？内存池 静态链表   其他类：重载new和delete

如何设计？

内存池：用静态链表实现（静态链表，即用数组描述的链表）；静态链表中基本单位是node结点；如图为6个结点，每个结点的指针域都存放下一个结点的地址，这样这6个结点就连在一起。

node结点有数据域和指针域，数据域为T类型（T为模板），指针域为 node* 类型 

其他类需要资源的类：要重载new和delete。即我们的类要重载new和delete，new调用内存池的alloc函数，delete调用内存池的delloc函数。new和delete最终操作的都是结点。

内存池的精髓在于内存池自己管理这些结点：即做好 alloc和delloc 的任务。

内存池申请内存 ：alloc：

内存池归还内存 ：delloc：

如图归还第一个node：

再归还第三个：

你会发现这样设计很是神奇。不管你怎么申请，怎么归还，最终还是这个内存池，妙就妙在结点之间通过结点之间通过指针域连接在一起。

并且这个机制还可以自己扩容。。。并且也不会内存泄漏...后面测试就会发现。

如图内存池用完后：

 

再申请，就pool指向新的内存块：（之前的会内存泄漏？？？no）

 

如果再归还之前内存池中的某个node，如图： 

来分析代码：

template<typename T>
class Memory_Pool  //内存池
{
public:
	void* alloc(size_t size)   //即申请内存
	{
		if (pool == NULL)   //pool指针为空，说明第一次申请，则申请一个内存池
		{
			pool = (Node*)new char[(size + 4) * 10]();//申请10倍所需资源；+4：数据域后面要加指针域
			Node* pCur = pool;
			for (pCur; pCur < pool + 10 - 1; pCur = pCur + 1)//循环，让每个node的指针域指向下一个node
			{
				pCur->pnext = pCur + 1;
			}
			pCur->pnext = NULL;//最后一个node的next域为NULL
		}
        Node* prt = pool;
		pool = pool->pnext;
		return prt;
	}

	void dealloc(void* mptr) //释放内存
	{
		if (mptr == NULL)
			return;
		Node* ptr = (Node*)mptr;
		ptr->pnext = pool;
		pool = ptr;
	}
private:
	class Node    //结点：数据域和指针域
	{
	public:
		Node(T val = T()) :mdata(val), pnext(NULL){}
	public:
		T mdata;    //数据域是一个T类型的数据   设计成模板：多态的体现
		Node* pnext;  //指针域
	};
	static Node* pool;   //设计成static 
    //静态数据成员被当作是类的成员。无论这个类的对象定义了多少个，
    //静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问
};
template<typename T>
typename Memory_Pool<T>::Node* Memory_Pool<T>::pool = NULL;

class Test   //一个需要申请堆内存资源的类
{
public:
	Test(int a) :ma(a){}
	void* operator new(size_t size) //重载new
	{
		return mp.alloc(size);//调用内存池pool的申请内存方法 
	}
	void operator delete(void* ptr)  //重载delete
	{
		mp.dealloc(ptr);//调用内存池pool的释放内存方法
	}
private:
	int ma;
	static Memory_Pool<Test> mp;//设计成static 
    //静态数据成员被当作是类的成员。无论这个类的对象定义了多少个，
    //静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问
};
Memory_Pool<Test> Test::mp;

int main()
{
	//int* p = new int(10);
	Test* ptest = NULL;
	for (int i = 0; i < 20; i++)
	{
		ptest = new Test(20);
	}
	
	return 0;
}