第21章回调与内存管理

课程目录第21章回调与内存管理

回调与内存管理：回调中动态分配内存的注意事项

说实话，回调函数里搞内存分配，是我见过翻车最多的地方之一。我自己早年也踩过坑，有一次产品上线后偶发崩溃，查了三天，最后定位到回调里一个 malloc 没配对 free。嗯，从那以后我对这块就特别敏感。

今天咱们就聊聊，在回调机制中动态分配内存时，有哪些容易忽略的细节，以及怎么避免。

一、谁分配，谁释放？——所有权必须明确

回调函数里分配内存，最核心的问题就是：这块内存归谁管？

我习惯把内存的所有权分成三种情况：

回调内部自产自销：分配、使用、释放都在回调里完成
回调分配，外部释放：回调把指针传出去，由调用方负责释放
外部分配，回调使用：调用方分配好内存，回调只负责读写

你想想看，如果所有权不明确，就会出现「回调里 malloc 了，但没人 free」或者「外部释放了，回调还在用」的惨案。

核心原则：谁分配，谁释放。如果跨模块传递，必须在接口文档里写清楚。

二、回调中 malloc，外部 free 的典型模式

这种模式很常见。比如一个事件驱动的系统，回调里根据事件类型生成数据，然后交给主循环处理。

// 回调函数：分配内存并返回数据
void* on_event_received(int event_type, void* context) {
    char* data = (char*)malloc(128);
    if (!data) return NULL;
    
    snprintf(data, 128, "Event %d occurred", event_type);
    return data;  // 所有权转移给调用方
}

// 调用方
void process_events() {
    void* result = on_event_received(42, NULL);
    if (result) {
        printf("Got: %s\n", (char*)result);
        free(result);  // 必须释放
    }
}

这里有个坑：回调返回后，调用方必须记得释放。我在项目中见过有人写了回调，但调用方忘了 free，结果内存泄漏。更隐蔽的是，如果回调在某些路径下返回 NULL，调用方也要处理，不能对 NULL 调用 free（虽然 free(NULL) 是安全的，但后续逻辑可能出问题）。

三、回调中使用外部传入的缓冲区

我个人更推荐这种方式：调用方分配缓冲区，回调只往里写数据。这样所有权清晰，不容易泄漏。

// 回调类型：传入缓冲区指针和大小
typedef void (*fill_buffer_cb)(char* buffer, size_t size, void* context);

void fill_buffer_callback(char* buffer, size_t size, void* context) {
    snprintf(buffer, size, "Hello from callback");
}

// 调用方
void use_callback() {
    char buf[256];  // 栈上分配，自动释放
    fill_buffer_callback(buf, sizeof(buf), NULL);
    printf("Buffer: %s\n", buf);
}

你看，这样根本不用 malloc 和 free，省心多了。但要注意：回调不能写超出缓冲区大小的数据，否则就是缓冲区溢出。我建议回调里始终使用 snprintf、strncpy 这类带长度限制的函数。

四、回调中分配链表或复杂结构

有时候回调需要构建复杂的数据结构，比如链表。这时候内存管理就更讲究了。

typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 回调：构建链表
Node* build_list_callback(void* context) {
    Node* head = NULL;
    Node* tail = NULL;
    
    for (int i = 0; i < 5; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        if (!node) {
            // 分配失败，需要释放已分配的内存
            free_list(head);
            return NULL;
        }
        node->data = i;
        node->next = NULL;
        
        if (!head) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }
    return head;
}

// 外部释放整个链表
void free_list(Node* head) {
    Node* current = head;
    while (current) {
        Node* next = current->next;
        free(current);
        current = next;
    }
}

这里有个关键点：如果中途 malloc 失败，必须把之前分配的全部释放，不能只返回 NULL 了事。否则那些已经分配的内存就泄漏了。我曾经在一个网络协议栈里见过这种 bug，压力测试下内存越涨越高，最后 OOM 被内核杀掉。

五、回调中分配内存的避坑指南

我曾经踩过的坑，列出来给你参考：

不要在回调里分配超大内存——回调可能被频繁调用，堆碎片会越来越严重
注意回调的执行上下文——如果在中断服务函数里 malloc，很多 RTOS 会崩溃
考虑使用内存池——如果回调分配的内存大小固定，用内存池比 malloc 更高效、更可控
记录分配来源——调试时给每个 malloc 加上标签，方便追踪泄漏

我的一个小技巧：在回调的接口设计上，尽量让调用方提供分配好的缓冲区。如果实在需要回调自己分配，那就定义一个配套的释放函数，成对出现。比如：

// 回调分配
void* create_data(void* context);
// 配套释放
void destroy_data(void* data);

这样调用方一看就知道：哦，这个 create_data 分配的内存要用 destroy_data 释放。

六、知识体系图

下面这张图总结了回调中动态内存分配的核心要点：

七、总结

回调中的内存管理，说白了就是「谁的孩子谁抱走」。分配和释放要成对出现，所有权要清晰，上下文要考虑周全。

我个人建议：能不用 malloc 就不用。如果回调只是临时处理数据，让调用方传缓冲区进来。如果非要分配，那就设计好配套的释放接口，并且在文档里写清楚。

嗯，最后再啰嗦一句：写回调的时候，多想想「这块内存最后谁来释放？」 想清楚了再动手，能省掉后面很多调试的功夫。