初探C++内存池项目 ---（一）链式栈的实现和原理详解

一.项目介绍

本项目是楼主在实验楼中学习的，这里主要分享一下学习心得和总结一些经验~

在 C/C++ 中，内存管理是一个非常棘手的问题，我们在编写一个程序的时候几乎不可避免的要遇到内存的分配逻辑，这时候随之而来的有这样一些问题：是否有足够的内存可供分配? 分配失败了怎么办? 如何管理自身的内存使用情况? 等等一系列问题。在一个高可用的软件中，如果我们仅仅单纯的向操作系统去申请内存，当出现内存不足时就退出软件，是明显不合理的。正确的思路应该是在内存不足的时，考虑如何管理并优化自身已经使用的内存，这样才能使得软件变得更加可用。本次项目我们将实现一个内存池，并使用一个栈结构来测试我们的内存池提供的分配性能。

二.内存池介绍

内存池是池化技术中的一种形式。通常我们在编写程序的时候回使用 new delete 这些关键字来向操作系统申请内存，而这样造成的后果就是每次申请内存和释放内存的时候，都需要和操作系统的系统调用打交道，从堆中分配所需的内存。如果这样的操作太过频繁，就会找成大量的内存碎片进而降低内存的分配性能，甚至出现内存分配失败的情况。
而内存池就是为了解决这个问题而产生的一种技术。从内存分配的概念上看，内存申请无非就是向内存分配方索要一个指针，当向操作系统申请内存时，操作系统需要进行复杂的内存管理调度之后，才能正确的分配出一个相应的指针。而这个分配的过程中，我们还面临着分配失败的风险。
所以，每一次进行内存分配，就会消耗一次分配内存的时间，设这个时间为 T，那么进行 n 次分配总共消耗的时间就是 nT；如果我们一开始就确定好我们可能需要多少内存，那么在最初的时候就分配好这样的一块内存区域，当我们需要内存的时候，直接从这块已经分配好的内存中使用即可，那么总共需要的分配时间仅仅只有 T。当 n 越大时，节约的时间就越多。

三.项目源码及分析

源码地址：
https://github.com/82457097/Linux/tree/master/MemoryPool

1.链式栈的实现

#ifndef STACK_ALLOC_H
#define STACK_ALLOC_H

#include<memery>	//std::allocator函数需要的头文件

template<typename T>
struct StackNode {		//创建模板化链表
	T data;
	StackNode* next;
};

template<typename T, typename Alloc = std::allocator<T>>
class StackAlloc {	//链式栈的模板类，主要实现栈的一些基本功能，push、pop、top、还有判空empty、销毁clear等等~
public:
	//取别名，方便书写。
	typedef StackNode Node;
	typedef typename Alloc::template rebind<Node>::other allocator;//这里下面会做详细解释
	
	//构造函数,将链表的头结点初始化一下就好了
	StackAlloc() { m_head = nullptr; }
	//析构函数，直接调用Clear()销毁销毁所有内存
	~StackAlloc() { Clear(); }
	//入栈函数Push()
	void Push(T element) {
		//先调用allocate和construct创建一个新的节点，建议先去看一下std::allocator的成员函数说明
		Node* curr = m_allocator.allocate(1);
		m_allocator.construct(curr, Node());
		//然后直接头插法将新建的节点插入链表
		curr->data = element;
		curr->next = m_head;
		m_head = curr;
	}
	//弹栈Pop()
	T Pop() {
		//思路就是将节点的数据弹出，然后销毁节点。
		T result = m_head->data;
		//创建一个临时节点保存m_head->next
		Node* ptemp = m_head->next;
		//销毁头指针所指节点
		m_allocator.destroy(m_head);
		m_allocator.deallocate(m_head, 1);
		m_head = ptemp;

		return result;
	}
	//清空链式栈Clear()
	void Clear() {
		//循环判空销毁节点，直至每个节点都被销毁，内存被释放
		Node* curr = m_head;
		//从头结点开始判断
		while(curr != nullptr) {
			//新建一个Node来存放curr->next
			Node* ptemp = curr->next;
			//不为空则销毁此节点
			m_allocator.destroy(curr);
			m_allocator.deallocate(curr, 1);
			curr = ptemp;
		}
		m_head = nullptr;
	}
	//判断栈是否为空的函数Empty()
	bool Empty() { return (m_head == nullptr); }
	//取栈顶元素Top()
	T Top() { return m_head->data; }
	
private:
	Node* m_head;
	allocator m_allocator;
};

#endif

2.main函数测试效果

#include<iostream>
#include<ctime>
#include<cassert>
#include"StackAlloc.h"

#define ELEMS 100000 //这里是分配的个数 可以自己随便改
#define REPS 100	//重复分配次数

using namespace std;

int main() {
	clock_t start;	//clock()不清楚的去看一下clock()怎么用
	start = clock();
	StackAlloc<int, allocator<int>> stackDefault;
	for(int i = 0; i < REPS; ++i) {		//测试push和pop 100000x100 次所耗的时间
		assert(stackDefault.Empty());	//断言stackDefault未分配前是空的
		for(int j = 0; j < ELEMS; ++j)
			stackDefault.Push(j);
		for(int j = 0; j < ELEMS; ++j)
			stackDefault.Pop(j);
	}
	cout << "Default Alloc Time: ";
	cout << (((double)clock() - start) / CLOCKS_PER_SEC) << endl;	//算出实际花费的时间

	return 0;
}

以上代码完全是手打的，不确保没有小错误，这里只做思路的解释，项目源码连接已经放在上面了~

3.关于typedef typename Alloc::template rebind::other allocator用法的说明

//关于 typedef typename Alloc<T>::template rebind<Node>::other allocator 的解释

//我们用 typedef 给一个东西取了别名叫 allocator
//这个东西是

	typename Alloc::template rebind<Node>::other 

//它其实是为了解决编译器不认识的代码的问题而出现的写法
//首先我们定义了 Alloc = std::allocator<T>，而 rebind 其实是 std::allocator 的一个成员。
//巧就巧在，rebind 本身又是另一个模板， C++ 称其为 dependent name。完整的形式本来应该是：

	std::allocator<T>::rebind<Node>::other

//但是模板的相关解析已经在 <T> 出现过了，后面的 <Node> 中的 < 只能被解释为小于符号，这会导致编译出错。
//为了表示 dependent name 是一个模板，就必须使用 template 前缀。
//如果没有 template 前缀，< 会被编译器解释为小于符号。所以，我们必须写成下面的形式：

	std::allocator<T>::template rebind<Node>::other

//最后，编译器在其实根本没有任何办法来区分 other 究竟是一个类型，还是一个成员。
//但我们其实知道 other 是一个类型（见这里），所以使用 typename 来明确指出这是一个类型，最终才有了：

	typename std::allocator<T>::template rebind<Node>::other

//rebind的作用是，对于给定的类型T的分配器（typename Alloc = std::allocator<T>），
//想根据相同的策略得到另一个类型U的分配器（这里得到了std::allocator<StackNode_<T>>）。
	template<typename U> 
	struct rebind {
		typedef allocator other; 
	}; 

四.小结

这一篇主要解释了链式栈的作用及其原理，我们这里所测试的是系统的内存分配函数std::allocator的性能，下一篇我们将会实现自己的MemoryPool，与其进行性能上的比较，小伙伴们可以先自己研究MemoryPool的实现，有什么不懂得欢迎讨论，有错误或者建议也欢迎指正！
先附上最终性能比较图：次数都是100000x100

效果还是很明显的~