简单的malloc,free实现函数

简单的malloc,free实现函数

struct mem_control_block
{
    int is_avaliable;
    int size;
};

int has_initialized = 0;
void *managed_mem_start;
void *last_valid_address;

void mem_init()
{
    last_valid_address = sbrk(0);
    managed_mem_start = last_valid_address;
    has_initalized = 1;
}

void free(*firstbyte)
{
    struct mem_control_block *mcb;

    mcb = firstbyte - sizeof(struct mem_control_block);
    mcb->is_avaliable = 1;

    return;
}

void malloc(int numbyte)
{
    struct mem_control_block *current_mcb;
    void *mem_location,current_location;
    
    if(!has_initialized)
        mem_init();

    numbyte += sizeof(struct mem_control_block);
    mem_location = 0;
    current_location = managed_mem_start;

    while(current_location != last_valid_address)
    {
        current_mcb = (struct mem_control_block *)current_location;
        if(current_mcb->is_avaliable)
            if(current_mcb->size >= numbyte)
            {
                current_mcb->is_avaliable = 0;
                mem_location = current_location;
                break;
            }
        //current_location += sizeof(struct mem_control_block);
        current_location += current_mcb->size;
    }

    if(!memlocation)
    {
        sbrk(numbyte);
        mem_location = last_valid_address;
        last_valid_address += numbyte;

        current_mcb = mem_location;
        current_mcb->is_avaliable = 0;
        current_mcb->size = numbyte;
    }

    mem_location += sizeof(struct mem_control_block);
    return mem_location;
}