内存池改进版——使用后嵌入式指针

通过嵌入式指针，进行改进，提高效率

#include<iostream>
#include<ctime>
using namespace std;


namespace myf
{
	//嵌入式指针
	class B
	{
	private:
		int m_i;
		int m_j;
	public:
		struct obj
		{
			obj* next;//结构中只有一个指针，指针地址即是结构体的首地址！
		};

		void func11()//当作main函数来用
		{
			B myb;
			B::obj* myptr = (B::obj*) & myb;//将类对象首地址赋值给类结构体的指针
			myptr->next = nullptr;//由于结构体只有一个地址！，即&myptr==myptr->next

		}
	};

	//利用嵌入式指针的内存池设计

	class myallocate //此内存池分配方案必须保证类大小不小于4字节
	{
	private:
		size_t m_TrunkCout = 5;//分配倍数
		struct obj    //嵌入式指针
		{
			struct obj* next;
		};
		obj* cur_ptr = nullptr;
	public:
		void* allocate(size_t size)//分配内存
		{
			obj* tmplink = nullptr;
			if (cur_ptr == nullptr)
			{
				size_t realsize = m_TrunkCout * size;
				cur_ptr = (obj*)malloc(realsize);
				tmplink = cur_ptr;
				for (int i = 0; i < m_TrunkCout - 1; ++i)//给定的倍数，代表有多少个size块
				{
					tmplink->next = (obj*)((char*)tmplink + size);//指向下一块
					tmplink = tmplink->next;
				}
				tmplink->next = nullptr;
			}
			tmplink = cur_ptr;
			cur_ptr = cur_ptr->next;
			return tmplink;
		}
		void deallocate(void* phead)
		{
			((obj*)phead)->next = cur_ptr;
			cur_ptr = (obj*)phead;
		}
	};
	class A//测试类，用以测试内存池函数
	{
	private:
		int mi;
		int mj;
	public:
		static myallocate myalloc;//调用内存池函数
		static void* operator new(size_t size)//分配内存
		{
			return myalloc.allocate(size);
		}
		static void operator delete(void* phead)//回收内存
		{
			return myalloc.deallocate(phead);
		}
	};
	myallocate A::myalloc;//定义静态变量

	void func()//当成主函数
	{
		A* myp[100];
		for (int i = 0; i < 15; ++i)
		{
			myp[i] = new A();
			printf("%p\n", myp[i]);
		}
		for (int i = 0; i < 15; ++i)
		{
			delete myp[i];
		}

	}

}