简单实现内存分配

对象头文件

#ifndef MEMERY_POOL_H_
#define	MEMERY_POOL_H_

#define BUFFSIZE 1024
#define MAXSIZE 5

struct DataType
{
	char* data;
	struct DataType* next;
};

class MemeryPool
{
private:
	struct DataType* free_buff_list_;
	int free_count_;
public:
	MemeryPool();
	~MemeryPool();
	char* GetBuff();
	void ReturnBuff(char* buff);
};




#endif	//MEMERY_POOL_H_

对象源文件

#include <iostream>

#include "memery_pool.h"


MemeryPool::MemeryPool()
{
	free_buff_list_ = NULL;
	free_count_ = 0;
}

MemeryPool::~MemeryPool()
{
	while(free_count_ > 0)
	{
		DataType* head = free_buff_list_->next;
		free(free_buff_list_->data);
		free_count_--;
		free_buff_list_ = NULL;
		if(free_count_ > 0)
		{
			free_buff_list_ = head;
		}
	}
}

char* MemeryPool::GetBuff()
{
	if(free_buff_list_ == NULL)
	{
		char* buff = (char*)malloc(sizeof(char)*BUFFSIZE);
		std::cout<<"malloc buff"<<std::endl;
		return buff;
	}
	else
	{
		DataType* head = free_buff_list_;
		free_buff_list_ = free_buff_list_->next;
		head->next = NULL;
		free_count_--;
		std::cout<<"get buff"<<std::endl;
		return head->data;
	}
	return NULL;
}

void MemeryPool::ReturnBuff(char* buff)
{
	if(buff == NULL)
	{
		return ;
	}
	if(free_count_ < MAXSIZE)
	{
		DataType* head = new(DataType);
		head->data = buff;
		head->next = free_buff_list_;
		free_buff_list_ = head;
		free_count_++;		
		std::cout<<"collect buff"<<std::endl;
	}
	else
	{
		free(buff);
		buff = NULL;
		std::cout<<"free buff"<<std::endl;
	}
}

main文件

#include <conio.h>
#include <iostream>

#include <signal.h>

#include "memery_pool.h"

void GameOver(int signal)
{
	exit(0);
}

int main()
{
	MemeryPool buff;
	char* array[10];
	for(int i=0; i<10; i++)
	{
		array[i] = buff.GetBuff();
	}
	for(int i=0; i<10; i++)
	{
		buff.ReturnBuff(array[i]);
	}
	signal(SIGINT,GameOver);
	return 0;
}