7、内存管理的重构：从malloc/free到RAII模式、引入智能指针（C语言实现）、内存池技术

说实话，内存管理是C语言项目里最容易出问题的地方。我见过太多项目，代码写得挺漂亮，结果一跑起来就段错误、内存泄漏，查半天发现是某个地方忘了free。嗯，今天我们就来聊聊怎么把这块烂摊子收拾干净。

7.1 传统malloc/free的痛点

先说说我自己的经历。几年前我接手过一个嵌入式通信协议栈，代码量大概20万行。里面到处都是malloc和free，但最要命的是——很多函数有多个return路径，每个路径都得记得释放内存。你想想看，维护这种代码是什么感觉？

典型的坑长这样：

void process_data(Data *input) {
    Buffer *buf = (Buffer*)malloc(sizeof(Buffer));
    if (!buf) return;

    if (input->type == INVALID) {
        // 忘了free(buf)！
        return;
    }

    // 中间还有几个if判断
    if (some_error_condition) {
        free(buf);
        return;
    }

    // 正常处理
    free(buf);
}

这种代码我改过不下百次。每次加一个新条件判断，就得检查所有return路径有没有漏掉free。说白了，这是C语言天生的缺陷——没有析构函数，没有自动资源管理。

7.2 RAII模式：用结构体封装资源生命周期

RAII（Resource Acquisition Is Initialization）是C++里的概念，但C语言也能实现类似的效果。核心思想很简单：资源的获取和释放，绑定到对象的生命周期上。

在C语言里，我们可以用结构体+回调函数来模拟：

typedef struct {
    void *data;
    void (*destroy)(void*);
} RAII_Resource;

RAII_Resource* raii_create(size_t size, void (*destroy_fn)(void*)) {
    RAII_Resource *res = (RAII_Resource*)malloc(sizeof(RAII_Resource));
    if (!res) return NULL;

    res->data = malloc(size);
    if (!res->data) {
        free(res);
        return NULL;
    }

    res->destroy = destroy_fn;
    return res;
}

void raii_destroy(RAII_Resource *res) {
    if (res) {
        if (res->destroy) {
            res->destroy(res->data);
        }
        free(res->data);
        free(res);
    }
}

使用的时候，你只需要保证在作用域结束时调用raii_destroy。我个人习惯用宏来强制这个行为：

#define RAII_SCOPE(res) \
    for (int _raii_flag = 1; _raii_flag; \
         _raii_flag = 0, raii_destroy(res))

// 使用示例
void process() {
    RAII_Resource *buf = raii_create(1024, free_buffer);
    if (!buf) return;

    RAII_SCOPE(buf) {
        // 在这里使用buf，离开作用域自动释放
        do_something(buf->data);
    }
}

7.3 智能指针的C语言实现

说到智能指针，很多人觉得这是C++的专利。其实不然，C语言也能实现引用计数的智能指针。我曾在某个物联网网关项目里自己撸了一套，效果还不错。

核心结构：

typedef struct {
    void *ptr;
    int *ref_count;
    void (*deleter)(void*);
} SmartPtr;

SmartPtr smart_ptr_create(void *ptr, void (*deleter)(void*)) {
    SmartPtr sp;
    sp.ptr = ptr;
    sp.ref_count = (int*)malloc(sizeof(int));
    if (sp.ref_count) {
        *sp.ref_count = 1;
    }
    sp.deleter = deleter;
    return sp;
}

SmartPtr smart_ptr_copy(SmartPtr sp) {
    if (sp.ref_count) {
        (*sp.ref_count)++;
    }
    return sp;
}

void smart_ptr_destroy(SmartPtr *sp) {
    if (!sp || !sp->ref_count) return;

    (*sp->ref_count)--;
    if (*sp->ref_count == 0) {
        if (sp->deleter) {
            sp->deleter(sp->ptr);
        }
        free(sp->ptr);
        free(sp->ref_count);
        sp->ptr = NULL;
        sp->ref_count = NULL;
    }
}

使用场景：

void process_data() {
    MyData *data = (MyData*)malloc(sizeof(MyData));
    // 初始化data...

    SmartPtr sp1 = smart_ptr_create(data, mydata_deleter);
    SmartPtr sp2 = smart_ptr_copy(sp1);  // 引用计数变为2

    // 使用sp1和sp2...

    smart_ptr_destroy(&sp1);  // 引用计数减为1
    smart_ptr_destroy(&sp2);  // 引用计数减为0，自动释放
}

7.4 内存池技术：告别频繁malloc

频繁调用malloc/free有两个问题：一是性能开销大，二是会产生内存碎片。我做过一个实时音频处理项目，每秒要分配释放上千个小块内存，用malloc根本扛不住。后来换成了内存池，性能提升了5倍。

内存池的基本思路：一次性申请大块内存，然后切成固定大小的块，用链表管理空闲块。

typedef struct MemBlock {
    struct MemBlock *next;
} MemBlock;

typedef struct {
    MemBlock *free_list;
    size_t block_size;
    size_t pool_size;
    void *pool_start;
} MemoryPool;

MemoryPool* pool_create(size_t block_size, size_t block_count) {
    MemoryPool *pool = (MemoryPool*)malloc(sizeof(MemoryPool));
    if (!pool) return NULL;

    pool->block_size = block_size;
    pool->pool_size = block_size * block_count;
    pool->pool_start = malloc(pool->pool_size);
    if (!pool->pool_start) {
        free(pool);
        return NULL;
    }

    // 初始化空闲链表
    pool->free_list = (MemBlock*)pool->pool_start;
    MemBlock *current = pool->free_list;
    for (size_t i = 1; i < block_count; i++) {
        current->next = (MemBlock*)((char*)pool->pool_start + i * block_size);
        current = current->next;
    }
    current->next = NULL;

    return pool;
}

void* pool_alloc(MemoryPool *pool) {
    if (!pool->free_list) return NULL;

    MemBlock *block = pool->free_list;
    pool->free_list = block->next;
    return (void*)block;
}

void pool_free(MemoryPool *pool, void *ptr) {
    MemBlock *block = (MemBlock*)ptr;
    block->next = pool->free_list;
    pool->free_list = block;
}

void pool_destroy(MemoryPool *pool) {
    if (pool) {
        free(pool->pool_start);
        free(pool);
    }
}

7.5 三种技术的对比与选择

我整理了一张表，方便你根据项目情况做选择：

我个人建议：能不用malloc就不用。如果项目刚起步，优先考虑内存池。如果资源类型多变，用RAII模式兜底。智能指针嘛，除非你真的需要共享所有权，否则别给自己找麻烦。

7.6 知识体系总览

下面这张图概括了本章的核心逻辑：

说白了，内存管理重构的核心就三件事：减少手动释放、避免重复分配、消除碎片。RAII帮你管好生命周期，智能指针解决共享问题，内存池搞定性能瓶颈。三者不是互斥的，我经常在一个项目里同时用两三种。

公众号:蓝海资料掘金营，微信deep3321