<@乌龟:>手动实现C语言运行库(1) 堆内存分配,malloc and free

    最近看到了<程序员的自我修养>这本书, 对书中大部分的底层知识兴趣不算太大,不过对最后的一章,C语言运行库的实现非常的感兴趣,于是就依葫芦画瓢的实现了一下,今天花了一点时间完成了堆内存分配的内容.

    就不多说太多了,直接贴贴代码,方便自己和别人日后查询,另外代码中有几处的错误,这里也标明了.

//定义的一个Helper结构体,描述一片空间
typedef struct _heap_helper
{
    //是否这个空间被使用
    enum
    {
        HEAP_BLOCK_FREE = 0xABABABAB,
        HEAP_BLOCK_USED = 0xCDCDCDCD,
    } type;

    //这片空间的大小(含头部)
    unsigned size;
    struct _heap_helper* next;
    struct _heap_helper* prev;
} heap_header;

#define ADDR_ADD(a,o) (((char*)(a)) + o)
#define HEADER_SIZE (sizeof(heap_helper))

static heap_header* list_head = NULL;

void* malloc(unsigned size)
{
    heap_header *header;

    if (size == 0)
    {
        return NULL;
    }

    header = list_head;
    while (header != NULL)
    {
        //如果这片空间已经被使用,则跳至下片空间
        if (header->type == HEAP_BLOCK_USED)
        {
            header = header->next;
            continue;
        }

        //如果刚好能够容纳size的内存,则标记
        if (header->size > size + HEADER_SIZE &&
            header->size <= size + HEADER_SIZE * 2)
        {
            header->type = HEAP_BLOCK_USED;
            //原书的错误, 没有这个return
            return ADDR_ADD(header,HEADER_SIZE);
        }

        //如果这片空间足够大,则分割
        if (header->size > size + HEADER_SIZE * 2)
        {
            heap_header* next = (heap_header*)ADDR_ADD(header,size + HEADER_SIZE);
            next->prev = header;
            next->next = header->next;
            next->type = HEAP_BLOCK_FREE;
            next->size = header->size - (size - HEADER_SIZE);
            header->next = next;
            header->size = size + HEADER_SIZE;
            header->type = HEAP_BLOCK_USED;
            return ADDR_ADD(header,HEADER_SIZE);
        }
        header = header->next;
    }
    return NULL;
}

void free(void* ptr)
{
    //首先找到头部
    heap_header* header = (heap_header*)ADDR_ADD(ptr, -HEADER_SIZE);

    //如果头部标志没有被使用
    if (header->type != HEAP_BLOCK_USED)
    {
        return;
    }

    //标记
    header->type = HEAP_BLOCK_FREE;

    //检查前面一块内存是否空,否则合并
    if (header->prev != NULL && header->prev->type == HEAP_BLOCK_FREE)
    {
        header->prev->next = header->next;
        if (header->next != NULL)
        {
            header->next->prev = header->prev;
        }

        header->prev->size += header->size;
        header = header->prev;
    }

    //检查后面一块内存是否为空,否则合并
    if (header->next != NULL && header->next->type == HEAP_BLOCK_FREE)
    {
        header->size += header->next->size;
        header->next->next->prev = header;
        header->next = header->next->next;
    }
}

int heap_init()
{
    void* base = NULL;
    heap_header* header = NULL;

    //初始堆大小默认为32M
    unsigned heap_size = 1024 * 1024 * 32;

    //调用VirtualAlloc函数分配
    base = VirtualAlloc(0, heap_size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (base == NULL)
    {
        return 0;
    }

    header = (heap_header*)base;
    header->size = heap_size;
    header->type = HEAP_BLOCK_FREE;
    header->next = NULL;
    header->prev = NULL;

    list_head = header;
    return 1;
}