内存池的实现3 固定大小的allocator单线程内存配置器

如果我们想使内存管理器用于其他大小不同的类该怎么办呢？为每一个类重复管理逻辑显然是对开发时间的不必要浪费。如果我们看一下前面内存管理器的实现，就会明显地看出内存管理逻辑实际上独立于特定的类 有关的是对象的大小一这是内存池模板实现的良好候选。内存池将管理某种类型的一个可用对象池。模板实现将允许我们把管理的特定对象多样化。
值得注意的是 到目前为止的内存配置器都是只支持单线程的 要对多线程支持得上锁，下面固定大小 的大小是allocate_1 的大小为基准。

#include       // placement new
#include   // ptrdiff_t size_t
#include   // exit
#include   // UINT_MAX
#include  // cerr
template
class allcator_1
{
	    public:
        typedef T value_type;
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;

    public:
        static pointer allocate(size_type n, const void* hint = 0)
        {
			return static_cast(operator new(n));
        }

		static void deallocate(pointer ptr) {
			operator delete(static_cast(ptr));
		}

		static void construct(pointer ptr) {
			new (ptr) T;
		}
		static void destroy(pointer ptr) {
			ptr->~T();
		}
private:
	struct obj {
		unsigned long mile;
		char type;
	};
	union
	{
		obj b;
		allcator_1* next;
	};

public:
	unsigned long getMiles() { return b.mile; }
	char getType() { return b.type; }
	void set(unsigned long m, char t) {
		b.mile = m;
		b.type = t;
	}

	static void* operator new(size_t size);
	static void operator delete(void* phead);
	static int m_iCount;
	// 用于分配计数统计，每new一次 + 1
	static int m_iMallocCount;
	//用于统计ma11oc次数，每ma11oc一次+1
private:
	static allcator_1* m_FreePosi;
	// 总是指向一块可以分配出去的内存的首地址
	static int m_sTrunkCount;
	//一次分配多少倍该类的内存
};
template
void* allcator_1::operator new(size_t size)
{
	allcator_1* p = m_FreePosi;
	if (p)	//如果p有效就把链表头部向下移
		m_FreePosi = p->next;
	else
	{
		//如果链表已空，申请一大块内存
		int size =   (sizeof(allcator_1) > sizeof(T)) ? sizeof(allcator_1) : sizeof(T);
		allcator_1* newBlock = static_cast(::operator new(m_sTrunkCount * size));

		//将小块穿成一个freelist
		for (int i = 1; i < m_sTrunkCount - 1; ++i)
			newBlock[i].next = &newBlock[i + 1];
		newBlock[m_sTrunkCount - 1].next = 0;
		p = newBlock;
		m_FreePosi = &newBlock[1];
	}
	return p;
}
template
void allcator_1 :: operator delete(void* phead)
{
	//free(phead);
	//不再用传统方式实现，针对内存池有特别的实现
	(static_cast (phead))->next = m_FreePosi;
	m_FreePosi = static_cast (phead);
}
template
int allcator_1::m_iCount = 0;
template
int allcator_1::m_iMallocCount = 0;
template
allcator_1* allcator_1::m_FreePosi = nullptr;
template
int allcator_1::m_sTrunkCount = 5;
//一次分配5倍的该类内存作为内存池的大小

class MyClass
{
public:
	MyClass();
	~MyClass();
	void getA() {
		std::cout << a << std::endl;
	}

private:
	int a;
	int b;
	int c;

};

MyClass::MyClass():a(100),b(200),c(300)
{
	std::cout << "MyClass()" << std::endl;
	
}

MyClass::~MyClass()

{
	getA();
	std::cout << "~MyClass()" << std::endl;
}
int main() {
	allcator_1 alloc;
	MyClass* m = alloc.allocate(4);
	printf("%pn", m);
	alloc.construct(m);
	alloc.destroy(m);
	alloc.deallocate(m);

}