malloc 与 free 的那些坑：C/C++ 内存管理的常见漏洞与踩坑实录

一、内存泄漏（Memory Leak）

1. 忘记 free

void foo() {
    int *p = (int *)malloc(sizeof(int) * 10);
    // 使用 p ...
    // 忘记 free(p)
}

void foo() {
    int *p = (int *)malloc(sizeof(int) * 10);
    if (!p) return;

    // 使用 p ...

    free(p);
    p = NULL;  // 防止悬空指针
}

2. 提前 return / goto 导致漏 free

int process() {
    char *buf1 = malloc(1024);
    char *buf2 = malloc(2048);

    if (some_error) {
        return -1;  // buf1 和 buf2 都没释放！
    }

    free(buf1);
    free(buf2);
    return 0;
}

int process() {
    char *buf1 = NULL;
    char *buf2 = NULL;
    int ret = -1;

    buf1 = malloc(1024);
    buf2 = malloc(2048);
    if (!buf1 || !buf2)
        goto cleanup;

    if (some_error)
        goto cleanup;

    ret = 0;
cleanup:
    free(buf1);
    free(buf2);
    return ret;
}

二、悬空指针（Dangling Pointer）

free 后继续使用

int *p = malloc(sizeof(int));
*p = 10;
free(p);
*p = 20;  // 未定义行为！

• 程序直接崩溃（SIGSEGV）
• 数据被其他变量覆盖，产生诡异 Bug
• 暂时“看起来正常”，但在特定条件下炸裂

free(p);
p = NULL;

三、重复释放（Double Free）

char *p = malloc(100);
free(p);
free(p);  // double free！

free(p);
p = NULL;

// 后续再 free(p) 就是安全的，free(NULL) 是合法的空操作

四、越界访问（Buffer Overflow / Underflow）

写越界

int *arr = malloc(sizeof(int) * 5);
for (int i = 0; i <= 5; i++) {  // i = 5 越界
    arr[i] = i;
}
free(arr);

读越界

char *str = malloc(6);
strcpy(str, "hello");
char c = str[6];  // 越界读

五、不匹配的分配/释放

malloc / free 混用 new / delete

int *p = (int *)malloc(sizeof(int));
delete p;  // 未定义行为

int *p = new int[10];
free(p);  // 未定义行为

• 内存泄漏
• 析构函数不被调用（C++ 对象）
• 堆损坏

六、sizeof 的经典陷阱

对指针用 sizeof

int *arr = malloc(sizeof(arr) * 10);  // 错误！

int *arr = malloc(sizeof(*arr) * 10);
// 或者
int *arr = malloc(sizeof(int) * 10);

七、内存未初始化

int *p = malloc(sizeof(int) * 10);
printf("%d\n", p[0]);  // 未初始化，值是垃圾值

int *p = calloc(10, sizeof(int));  // 所有元素初始化为 0

八、realloc 的陷阱

1. 直接覆盖原指针

p = realloc(p, new_size);  // 危险！

void *new_p = realloc(p, new_size);
if (!new_p) {
    // 处理错误，p 仍然有效
    free(p);
    return;
}
p = new_p;

2. realloc(0)

p = realloc(p, 0);  // 行为是实现定义的

九、释放栈内存

int x;
int *p = &x;
free(p);  // 未定义行为！

十、结构体中的指针成员

typedef struct {
    char *name;
} Person;

Person *p = malloc(sizeof(Person));
p->name = malloc(64);
// ...
free(p);  // name 指向的内存泄漏了！

free(p->name);
free(p);

十一、多线程下的内存问题

// 线程 A
free(p);

// 线程 B
*p = 10;  // 悬空指针

十二、防御性编程建议

1. 谁分配，谁释放

2. 使用工具检测

3. C++ 优先使用智能指针

std::unique_ptr<int[]> arr(new int[10]);
// 或
auto arr = std::make_unique<int[]>(10);

总结