20、宏与内存管理：自定义内存分配器宏

内存管理，说白了就是C语言里最让人头疼的事。我做了十几年嵌入式开发，见过太多因为内存泄漏、越界访问导致的诡异bug。有些问题查了三天三夜，最后发现就是少了个free。嗯，今天我们就用宏来武装自己，让内存管理变得可控一些。

20.1 为什么需要包装malloc/free？

直接调用malloc/free有什么问题？我举个例子。你在代码里写了100个malloc，项目上线后内存持续增长。你根本不知道哪个malloc没配对free。更别说嵌入式环境里，内存碎片、对齐要求这些坑了。

所以我的习惯是——永远不要直接调用裸的malloc。用宏包装一层，好处太多了：

  • 自动记录分配的文件名、行号
  • 统一错误处理（分配失败怎么办？）
  • 方便统计内存使用量
  • 可以插入调试断点

核心思想：用宏给内存操作加上“钩子”，让每次分配和释放都有迹可循。

20.2 基础包装宏：带调试信息的内存分配

先看一个最常用的包装。我在项目里几乎每个.c文件都会包含这个头文件：

#include <stdlib.h>
#include <stdio.h>

#define MY_MALLOC(size) \
    my_malloc_debug(size, __FILE__, __LINE__)

#define MY_FREE(ptr) \
    my_free_debug(ptr, __FILE__, __LINE__)

void* my_malloc_debug(size_t size, const char* file, int line) {
    void* ptr = malloc(size);
    if (ptr == NULL) {
        fprintf(stderr, "[MEM] malloc failed at %s:%d, size=%zu\n",
                file, line, size);
        // 这里可以加你的错误处理逻辑
    } else {
        printf("[MEM] malloc %p, size=%zu, at %s:%d\n",
               ptr, size, file, line);
    }
    return ptr;
}

void my_free_debug(void* ptr, const char* file, int line) {
    if (ptr) {
        printf("[MEM] free %p, at %s:%d\n", ptr, file, line);
    }
    free(ptr);
}

你看，__FILE__和__LINE__这两个预定义宏，帮我们自动抓到了调用位置。我曾经靠这个定位过一个bug——有个模块在中断里调了malloc，但中断里不允许阻塞操作。日志一打出来，文件行号清清楚楚，问题秒解。

小技巧：正式发布时，可以用条件编译把printf关掉。比如#define DEBUG_MEM 0时，这些日志就不编译进去，零开销。

20.3 内存泄漏检测宏

说实话，内存泄漏是嵌入式开发里最隐蔽的敌人。它不像段错误那样立刻崩溃，而是慢慢蚕食你的堆空间。我有个血的教训——一个数据采集设备跑了72小时后死机，就是因为一个循环里每次new了对象但没delete。

下面这个宏方案，可以帮你追踪所有未释放的内存块：

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

// 定义一个简单的链表节点，记录分配信息
typedef struct mem_node {
    void* ptr;
    size_t size;
    const char* file;
    int line;
    struct mem_node* next;
} mem_node_t;

static mem_node_t* mem_list = NULL;
static size_t total_allocated = 0;

#define TRACK_MALLOC(size) \
    track_malloc_debug(size, __FILE__, __LINE__)

#define TRACK_FREE(ptr) \
    track_free_debug(ptr, __FILE__, __LINE__)

void* track_malloc_debug(size_t size, const char* file, int line) {
    void* ptr = malloc(size);
    if (ptr == NULL) return NULL;

    // 记录到链表
    mem_node_t* node = (mem_node_t*)malloc(sizeof(mem_node_t));
    if (node) {
        node->ptr = ptr;
        node->size = size;
        node->file = file;
        node->line = line;
        node->next = mem_list;
        mem_list = node;
        total_allocated += size;
    }

    printf("[TRACK] + %p, size=%zu, at %s:%d, total=%zu\n",
           ptr, size, file, line, total_allocated);
    return ptr;
}

void track_free_debug(void* ptr, const char* file, int line) {
    if (ptr == NULL) return;

    // 从链表中移除
    mem_node_t** pp = &mem_list;
    while (*pp) {
        if ((*pp)->ptr == ptr) {
            mem_node_t* to_free = *pp;
            *pp = (*pp)->next;
            total_allocated -= to_free->size;
            printf("[TRACK] - %p, freed at %s:%d, total=%zu\n",
                   ptr, file, line, total_allocated);
            free(to_free);
            break;
        }
        pp = &(*pp)->next;
    }

    free(ptr);
}

// 在程序退出前调用，打印所有泄漏
void dump_leaks(void) {
    mem_node_t* node = mem_list;
    if (node == NULL) {
        printf("[LEAK] No memory leaks detected.\n");
        return;
    }

    printf("========== MEMORY LEAK REPORT ==========\n");
    size_t leak_total = 0;
    while (node) {
        printf("[LEAK] %p, size=%zu, allocated at %s:%d\n",
               node->ptr, node->size, node->file, node->line);
        leak_total += node->size;
        node = node->next;
    }
    printf("Total leaked: %zu bytes\n", leak_total);
    printf("========================================\n");
}

注意：这个方案本身也会malloc内存来存节点信息。如果系统堆空间极度紧张，可以考虑用静态数组代替链表。我在一个RTOS项目里就这么干过——预分配1024个节点槽位，用位图管理。

20.4 对齐分配宏

嵌入式里经常遇到对齐要求。比如DMA传输需要缓冲区16字节对齐，或者某些CPU访问未对齐地址会触发异常。标准malloc返回的地址是8字节对齐（32位系统）或16字节对齐（64位系统），但有时候不够。

我常用的对齐分配宏是这样写的：

#include <stdlib.h>
#include <stdint.h>

// 分配对齐内存，返回对齐后的指针
// 注意：释放时必须用 ALIGNED_FREE
#define ALIGNED_MALLOC(size, align) \
    aligned_malloc_debug(size, align, __FILE__, __LINE__)

#define ALIGNED_FREE(ptr) \
    aligned_free_debug(ptr, __FILE__, __LINE__)

void* aligned_malloc_debug(size_t size, size_t align,
                           const char* file, int line) {
    // 对齐必须是2的幂
    if ((align & (align - 1)) != 0) {
        fprintf(stderr, "[ALIGN] align must be power of 2, at %s:%d\n",
                file, line);
        return NULL;
    }

    // 多分配 align-1 字节，用于对齐调整
    // 再加 sizeof(void*) 字节，存储原始指针
    size_t total = size + align - 1 + sizeof(void*);
    void* raw = malloc(total);
    if (raw == NULL) return NULL;

    // 计算对齐后的地址
    uintptr_t raw_addr = (uintptr_t)raw;
    uintptr_t aligned_addr = (raw_addr + sizeof(void*) + align - 1) & ~(align - 1);

    // 在对齐地址前面存储原始指针
    ((void**)aligned_addr)[-1] = raw;

    printf("[ALIGN] raw=%p, aligned=%p, size=%zu, align=%zu, at %s:%d\n",
           raw, (void*)aligned_addr, size, align, file, line);

    return (void*)aligned_addr;
}

void aligned_free_debug(void* ptr, const char* file, int line) {
    if (ptr == NULL) return;

    // 取出原始指针
    void* raw = ((void**)ptr)[-1];
    printf("[ALIGN] free aligned=%p, raw=%p, at %s:%d\n",
           ptr, raw, file, line);
    free(raw);
}

这个实现有个关键点：我们在分配时多存了一个原始指针。为什么？因为free必须传入malloc返回的原始地址，不能传对齐后的地址。所以我们在对齐地址前面藏了个“小纸条”，记录真正的起点。

使用示例：

// 分配16字节对齐的256字节缓冲区
uint8_t* buf = (uint8_t*)ALIGNED_MALLOC(256, 16);
if (buf) {
    // 这里buf地址一定是16的倍数
    // 可以放心交给DMA使用
    ALIGNED_FREE(buf);
}

20.5 知识体系总览

下面这张图，把本章的核心逻辑串起来了：

宏与内存管理知识体系 基础包装宏 • 自动记录文件行号 • 统一错误处理 • 条件编译开关 • 零开销发布版本 内存泄漏检测 • 链表记录分配信息 • 释放时自动移除 • 统计总分配量 • 退出时打印报告 对齐分配宏 • 任意2的幂对齐 • 存储原始指针 • DMA缓冲区专用 • 避免CPU异常 核心目标：让内存操作可追踪、可控制、可调试 1. 所有malloc/free都经过宏包装，自动携带上下文信息 2. 泄漏检测宏在开发阶段捕获未释放的内存块 3. 对齐分配宏满足硬件特殊要求，同时保证释放安全 三个模块可以独立使用，也可以组合使用

20.6 组合使用与避坑指南

你可能会问：这三个宏能一起用吗？当然可以。我在一个通信协议栈项目里，就把泄漏检测和对齐分配组合起来了。不过要注意顺序——先做对齐分配，再在内部调用泄漏检测的malloc。

但有几个坑，我帮你提前踩过了：

  • 不要混用free和MY_FREE。 用MY_MALLOC分配的内存，必须用MY_FREE释放。否则链表记录会乱掉。
  • 对齐分配的内存，必须用ALIGNED_FREE。 直接free会崩溃，因为地址不对。
  • 多线程环境要加锁。 上面的链表操作不是线程安全的。我在RTOS里加了个互斥量保护。
  • 嵌入式里慎用printf。 调试阶段可以开，正式版一定要关掉。否则日志刷屏会影响实时性。

我的习惯：在头文件里统一用宏定义，然后通过一个全局的DEBUG_LEVEL来控制日志输出。比如DEBUG_LEVEL >= 2时打印详细分配信息，DEBUG_LEVEL >= 1时只打印错误。这样不用改代码，改个宏定义就行。

好了，这一章的内容就到这里。宏与内存管理的结合，说白了就是给C语言的内存操作加上“安全绳”。你想想看，每次malloc都自动记录位置，每次free都检查合法性，泄漏了还能出报告——这比裸写malloc/free强太多了。下次你在项目里遇到内存问题，不妨试试这些宏，说不定能省下好几个通宵的调试时间。

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

← 上一章 📖 返回目录 下一章 →