动态内存分配算法(最简单实现)
请教c语言实现类似malloc，free的函数，要求：
1）已知内存起始地址char* pMemStart,内存长度unsigned int iMemSize；
2）实现最简单的动态内存分配算法，不考虑效率，不考虑内存碎片；
3）只要实现malloc和free就行，如果有内存碎片，malloc失败返回空指针即可；
网上搜了几种算法，感觉太过复杂，大都追求性能，不适用我面对的需求，有高手支招吗？ 算法 malloc c语言 内存
[解决办法]
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
typedef struct memory_block_t memory_block;
struct memory_block_t
{
memory_block* next;
};
memory_block* freeStroe;
void _init_()
{
//puts(__FUNCTION__);
char theHeap[128 * 1024 * 1024]; //128M
memory_block* block;
freeStroe = (memory_block*)theHeap;
block = freeStroe;
while((char*)block + 128 < theHeap + 128 * 1024 * 1024)
{
block->next = (memory_block*)((char*)block + 128); //每128字节为一块
block = block->next;
}
block->next = 0;
}
//请求大小(0,128]
void * _malloc_(unsigned int size)
{
//puts(__FUNCTION__);
if(0 < size && size <= 128)
{
if(freeStroe)
{
void * ret = freeStroe;
freeStroe = freeStroe->next;
return ret;
}
}
return 0;
}
//p须是_malloc_返回的
void _free_(void* p)
{
//puts(__FUNCTION__);
if(p)
{
((memory_block*)p)->next = freeStroe;
freeStroe = ((memory_block*)p);
}
}
void* tmp[1024];
int main()
{
int i;
srand((unsigned int)time(NULL));
_init_();
for(i = 0; i < 1024; ++i)
{
tmp[i] = _malloc_(rand() + 1);
}
for(i = 0; i < 1024; ++i)
{
_free_(tmp[i]);
}
}
#ifndef __MY_MALLOC__H_
#define __MY_MALLOC__H_
/**/
void malloc_init();
void * my_malloc(int numbytes);
void my_free(void *firstbyte);
void Printf();
/**/
struct mem_control_block{
int is_available;
int size;
};
#endif
#include "my_malloc.h"
/**/
static int has_initialized = 0;
static void *managed_memory_start;
static void *last_valid_address;
void Printf()
{
printf("%p\n",last_valid_address);
}
void malloc_init()
{
last_valid_address = (void *)sbrk(0);
managed_memory_start = last_valid_address;
has_initialized = 1;
}
void my_free(void *firstbyte)
{
struct mem_control_block *mcb;
mcb = firstbyte - sizeof(struct mem_control_block);
mcb->is_available = 1;
}
void * my_malloc(int numbytes)
{
void * current_location;
void * memory_location;
struct mem_control_block *current_location_mcb;
if ( !has_initialized) malloc_init();
current_location = managed_memory_start;
numbytes += sizeof(struct mem_control_block);
while( current_location < last_valid_address)
{
current_location_mcb = ( struct mem_control_block * )current_location;
if(current_location_mcb->is_available && current_location_mcb->size >=numbytes)
{
current_location_mcb->is_available = 0;
memory_location = current_location + sizeof(struct mem_control_block);
return memory_location;
}
current_location = current_location + current_location_mcb->size;
}
/**/
sbrk(numbytes);
current_location = last_valid_address;
last_valid_address += numbytes;
current_location_mcb = ( struct mem_control_block * )current_location;
current_location_mcb->is_available = 0;
current_location_mcb->size = numbytes;
memory_location = current_location + sizeof(struct mem_control_block);
return memory_location;
}
