基于标准库malloc/free的内存泄漏检测方案及宏替换原理-CSDN博客

本文链接：https://blog.csdn.net/weixin_50859396/article/details/150395774

基于标准库的内存泄漏检测方案及宏替换原理详解

一、方案概述

本方案通过封装标准库 malloc/free 的封装实现内存泄漏检测，核心机制是：

对内存分配行为进行全程跟踪，记录每个内存块的关键信息（地址、大小、分配位置）
程序退出时自动扫描未释放的内存块，生成泄漏报告
采用宏替换技术无缝集成到现有代码，几乎无需修改业务逻辑

方案底层依赖标准库内存管理函数，无需直接操作操作系统接口，兼容性强，可在所有支持C语言的环境中使用。

二、核心实现

1. 头文件设计（`tracked_malloc.h`）

#ifndef TRACKED_MALLOC_H
#define TRACKED_MALLOC_H

#include <stddef.h>

// 函数声明：带跟踪的内存分配与释放
void* tracked_malloc(size_t size, const char* file, int line);
void tracked_free(void* ptr);

// 宏替换：将标准malloc/free映射到跟踪版本
// 自动传入文件名和行号，实现精准定位
#define malloc(size) tracked_malloc(size, __FILE__, __LINE__)
#define free(ptr) tracked_free(ptr)

#endif // TRACKED_MALLOC_H

2. 核心实现（`tracked_malloc.c`）

#include "tracked_malloc.h"
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>

// 内存分配跟踪节点：记录单个内存块的信息
typedef struct allocation_node {
    void* ptr;               // 内存块地址
    size_t size;             // 分配大小（字节）
    const char* file;        // 分配所在文件名
    int line;                // 分配所在行号
    struct allocation_node* next;  // 链表指针
} allocation_node;

// 全局状态：跟踪链表与线程安全锁
static allocation_node* alloc_list = NULL;
static pthread_mutex_t alloc_mutex = PTHREAD_MUTEX_INITIALIZER;

// 内部函数：添加分配记录（带线程安全保护）
static void add_allocation(void* ptr, size_t size, const char* file, int line) {
    // 临时取消宏替换，确保调用标准库malloc
#undef malloc
    allocation_node* node = (allocation_node*)malloc(sizeof(allocation_node));
    // 恢复宏替换
#define malloc(size) tracked_malloc(size, __FILE__, __LINE__)

    if (!node) {
        fprintf(stderr, "Failed to create allocation tracking node\n");
        return;
    }

    // 填充跟踪信息
    node->ptr = ptr;
    node->size = size;
    node->file = file;
    node->line = line;

    // 线程安全地插入链表
    pthread_mutex_lock(&alloc_mutex);
    node->next = alloc_list;
    alloc_list = node;
    pthread_mutex_unlock(&alloc_mutex);
}

// 带跟踪的内存分配实现
void* tracked_malloc(size_t size, const char* file, int line) {
    if (size == 0) return NULL;

    // 临时取消宏替换，调用标准库malloc
#undef malloc
    void* ptr = malloc(size);
    // 恢复宏替换
#define malloc(size) tracked_malloc(size, __FILE__, __LINE__)

    if (!ptr) {
        fprintf(stderr, "Memory allocation failed at %s:%d\n", file, line);
        return NULL;
    }

    // 记录分配信息
    add_allocation(ptr, size, file, line);
    return ptr;
}

// 内部函数：移除分配记录（带线程安全保护）
static int remove_allocation(void* ptr) {
    allocation_node* prev = NULL;
    allocation_node* curr = alloc_list;

    pthread_mutex_lock(&alloc_mutex);
    while (curr) {
        if (curr->ptr == ptr) {
            // 从链表中移除节点
            if (prev) prev->next = curr->next;
            else alloc_list = curr->next;

            // 临时取消宏替换，调用标准库free
#undef free
            free(curr);
            // 恢复宏替换
#define free(ptr) tracked_free(ptr)

            pthread_mutex_unlock(&alloc_mutex);
            return 1; // 成功移除
        }
        prev = curr;
        curr = curr->next;
    }
    pthread_mutex_unlock(&alloc_mutex);
    return 0; // 未找到记录
}

// 带校验的内存释放实现
void tracked_free(void* ptr) {
    if (!ptr) return;

    // 检查是否为跟踪中的内存块
    if (!remove_allocation(ptr)) {
        fprintf(stderr, "Invalid free: pointer %p was not allocated\n", ptr);
        return;
    }

    // 临时取消宏替换，调用标准库free
#undef free
    free(ptr);
    // 恢复宏替换
#define free(ptr) tracked_free(ptr)
}

// 泄漏检测函数：程序退出时自动执行
static void check_memory_leaks() {
    pthread_mutex_lock(&alloc_mutex);
    
    if (!alloc_list) {
        printf("\n=== No memory leaks detected ===\n");
        pthread_mutex_unlock(&alloc_mutex);
        return;
    }

    // 输出泄漏统计与详情
    printf("\n=== Memory Leak Detected ===\n");
    printf("Total leaked blocks: ");
    
    size_t count = 0;
    size_t total_size = 0;
    allocation_node* curr = alloc_list;
    while (curr) {
        count++;
        total_size += curr->size;
        curr = curr->next;
    }
    printf("%zu (%zu bytes)\n", count, total_size);

    // 打印详细信息
    printf("%-16s %-10s %-20s %s\n", "Address", "Size", "File", "Line");
    printf("------------------------------------------------------------\n");
    
    curr = alloc_list;
    while (curr) {
        printf("%-16p %-10zu %-20s %d\n",
               curr->ptr, curr->size, curr->file, curr->line);
        curr = curr->next;
    }

    pthread_mutex_unlock(&alloc_mutex);
}

// 注册泄漏检测函数（程序启动时执行）
static void __attribute__((constructor)) init_leak_checker() {
    atexit(check_memory_leaks);
}

三、宏替换原理与冲突解决方案

1. 宏替换的核心机制

替换时机：宏替换发生在预处理阶段（编译前），属于文本替换
替换范围：仅对宏定义之后出现的显式标识符进行替换
作用：通过 #define malloc(...) tracked_malloc(...) 将用户代码中的内存分配自动转为带跟踪的版本

2. 递归调用问题及解决方案

问题现象：若直接在 tracked_malloc 内部使用 malloc，可能被宏替换为 tracked_malloc 自身，导致无限递归。

解决方案：通过 #undef 临时取消宏替换，调用标准库函数后再用 #define 恢复：

// 在需要调用标准库malloc的位置：
#undef malloc           // 取消宏映射，恢复标准库malloc
void* ptr = malloc(size); // 实际调用标准库函数
#define malloc(size) tracked_malloc(size, __FILE__, __LINE__) // 恢复映射