欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

一个C语言内存管理模块的实现

程序员文章站 2022-05-14 09:12:14
C 内存管理模块的编写 C语言手动管理内存很困难,有时候很难发现内存泄漏,这两天看了一下里面有写了一个简单的内存管理模块,发现挺精巧,可以有效检测内存泄漏 原理很简单,就是把C的malloc函数分配的内存用一个链表记录起来,最后查看这个链表是否还有节点就可以判断是否有内存泄漏了 首先我们先看一下这个 ......

c 内存管理模块的编写

c语言手动管理内存很困难,有时候很难发现内存泄漏,这两天看了一下里面有写了一个简单的内存管理模块,发现挺精巧,可以有效检测内存泄漏

原理很简单,就是把c的malloc函数分配的内存用一个链表记录起来,最后查看这个链表是否还有节点就可以判断是否有内存泄漏了

首先我们先看一下这个链表的数据结构

//标记数组的大小
#define mark_size 4
typedef struct mem_header mem_header;
struct mem_header
{
    int size;//后面内存分配的大小
    mem_header *next;//下一个节点的指针
    mem_header *prev;//上一个节点的指针
    char *filename;//文件名指针
    int line;//在第几行
    unsigned char mark[mark_size];//标记数组,这个数据用来表示这块内存是否被破坏了
}

这个mark数组我们将用 0xcd填充,如果这个数组被动过了就说明这块内存被破坏了

我们每次malloc一块内存的时候,这个结构体就会被添加到这块内存的头部

就像这样:

void *p = malloc(size);
mem_header *header = (mem_header *)p;
//然后设置header信息
/*省略一些赋值过程*/
return (char*)header+sizeof(mem_header);

这样外部拿到的指针就可以随便用了,回收的时候还可以重新推出头部指针的信息,然后从链表中删除这个节点

为了防止后面溢出,可以在后面内存也加上 mark数组 这样我们每次分配的内存大小是 sizeof(mem_header) + size + mark_size其中size是需要分配的大小,mark_size是在后面加的标记数组

我们用malloc初始化的时候经常碰到0,我们把这块内存填充0xcc(没意义的值别的其实也行),更容易发现错误

memset(p, 0xcc, willalloc);

我们先来看第一个函数:

//size 需要分配的大小
//filename 文件名
//line 行好
void *mem_alloc(mem_controller *controller, size_t size, char *filename, int line)
{
    int willalloc = size + mem_header_size + mark_size;//实际分配大小
    void *p = malloc(willalloc);
    if (!p)
        controller->handle(controller, filename, line, "malloc null");
    //填充数组
    memset(p, 0xcc, willalloc);
    //设置头部一些信息
    mem_setheader(p, size, filename, line);
    //设置tail的信息
    mem_settail(p, size);
    //把这个节点添加到链表中
    mem_addchain(controller, (mem_header *)p);
    return (char *)p + mem_header_size;
}

这个函数就是分配一个内存,controller是控制器,实际上就是负责打印和保存头指针的

filename和line就是分配空间时候的文件和行号,可以用宏定义解决可以百度一下这两个宏__line__,__file__

内存释放:从链表中删除这个节点

void mem_free(mem_controller *controller, void *p, char *filename, int line)
{
    if (!p)
        return;
    //头信息
    mem_header *header = (char *)p - mem_header_size;
    //check header and tail
    //检查是不是mark数组损坏了
    mem_check(controller, header, filename, line);
    //移除节点
    mem_rmchain(controller, header);
    free(header);
}

打印所有链表中的节点

void mem_dumps(mem_controller *controller)
{
    mem_header *pos = controller->memheader;
    file *fp = stderr;
    int counter = 0;
    for (pos = controller->memheader; pos; pos = pos->next)
    {
        mem_check(controller, pos, pos->filename, pos->line);
        fprintf(fp, "[%04d]%p********************\n", counter,
                (char *)pos + mem_header_size);
        fprintf(fp, "%s line %d size..%d\n",
                pos->filename, pos->line, pos->size);
        counter++;
    }
}

为了方便我们使用,我们可以设置几个宏定义

typedef struct mem_controller mem_controller;
extern mem_controller *pcontrol;

void *mem_alloc(mem_controller *controller, size_t size, char *filename, int line);
void mem_free(mem_controller *controller, void *p, char *filename, int line);
void mem_dumps(mem_controller *controller);

#define current_mem_controller pcontrol
#define mem_alloc_func(size) mem_alloc(current_mem_controller, size, __file__, __line__)
#define mem_free_func(p) mem_free(current_mem_controller, p, __file__, __line__)
#define mem_dump_func() mem_dumps(current_mem_controller)

那个extern全局变量是别的文件定义的指针,__file__会自动替换文件名,这样我们就可以看到是哪里的内存没有被释放

使用的时候也简单了很多直接用宏定义就可以了

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mem.h"

void fill_buffer(unsigned char *buf, int size)
{
    int i;

    for (i = 0; i < size; i++)
    {
        buf[i] = i;
    }
}
void mem_print(unsigned char *p, int size)
{
    for (int i = 0; i < size; i++)
    {
        fprintf(stderr, "%02x", p[i]);
    }
    fprintf(stderr, "\n");
}

int main()
{
    void *p = mem_alloc_func(10);
    mem_print(p, 10);
    void *p2 = mem_alloc_func(10);
    mem_print(p2, 10);
    void *p3 = mem_alloc_func(10);
    mem_print(p3, 10);
    mem_dump_func();
    fprintf(stderr, "try to clear\n");
    mem_free_func(p2);
    mem_free_func(p);
    mem_free_func(p3);
    mem_dump_func();
    fprintf(stderr, "then to malloc\n");
    p = mem_alloc_func(10);
    fill_buffer(p, 10);
    p = mem_realloc_func(p, 20);
    mem_print(p, 24);
    mem_dump_func();
    return 0;
}

一个C语言内存管理模块的实现

我们可以看到泄漏的大小和行号

原版的代码的联合体是用来内存对齐的加快访问速度

自制编程语言>