【安全函数】free_s ()：对比 free () 解析 C 语言内存释放的安全升级

// 带错误码返回的实现（常见于安全库）
int free_s(void** ptr);

// 无返回值但增强校验的实现（自定义常用）
void free_s(void** ptr);

// free()的一级指针传递（无法修改原指针）
void free(void* ptr) {
    释放ptr指向的内存;
    ptr = NULL; // 仅修改函数内局部变量，外部指针仍为野指针
}

// free_s()的二级指针传递（可修改原指针）
void free_s(void** ptr) {
    释放(*ptr)指向的内存;
    *ptr = NULL; // 修改外部原指针变量（*ptr即原指针）
}

// free_s()的内存块头（对比free()新增magic字段）
typedef struct SafeMemBlockHeader {
    size_t size;          // 内存块总大小（含头信息）
    int is_free;          // 1=空闲，0=已分配
    unsigned int magic;   // 魔法值（如0x12345678，校验合法性）
    struct SafeMemBlockHeader *prev; // 前驱指针
    struct SafeMemBlockHeader *next; // 后继指针
} SafeMemHeader;

// free()的内存块头（无magic字段）
typedef struct MemBlockHeader {
    size_t size;
    int is_free;
    struct MemBlockHeader *prev;
    struct MemBlockHeader *next;
} MemHeader;

// free()的内存布局
+-------------------+-------------------------+
| MemHeader         | 用户内存区（ptr指向）    |
| - size            |                         |
| - is_free         |                         |
| - prev/next       |                         |
+-------------------+-------------------------+

// free_s()的内存布局（多magic字段）
+-------------------+-------------------------+
| SafeMemHeader     | 用户内存区（*ptr指向）  |
| - size            |                         |
| - is_free         |                         |
| - magic（新增）   |                         |
| - prev/next       |                         |
+-------------------+-------------------------+

// 魔法值定义（固定值，用于校验内存合法性）
#define SAFE_MEM_MAGIC 0x12345678

int free_s(void** ptr) {
    // --------------- 差异点1：二级指针一级校验 ---------------
    // free()无此步骤：先检查二级指针是否为NULL（避免解引用空指针）
    if (ptr == NULL) {
        fprintf(stderr, "Error: free_s() param 'ptr' is NULL\n");
        return -1; // 返回错误码，不崩溃
    }

    // --------------- 差异点2：原指针二级校验 ---------------
    // free()仅检查ptr==NULL，此处检查*ptr（原指针）是否为NULL
    void* real_ptr = *ptr;
    if (real_ptr == NULL) {
        fprintf(stderr, "Warning: free_s() target ptr is NULL（无需释放）\n");
        return -2; // 无需释放，返回警告码
    }

    // 步骤3：获取安全内存块头（同free()的指针偏移逻辑）
    SafeMemHeader* header = (SafeMemHeader*)real_ptr - 1;

    // --------------- 差异点3：内存合法性三级校验 ---------------
    // free()无此步骤：校验魔法值（确保是本模块分配的动态内存）
    if (header->magic != SAFE_MEM_MAGIC) {
        fprintf(stderr, "Error: free_s() target is not safe dynamic memory\n");
        return -3; // 非法内存，返回错误码
    }

    // --------------- 差异点4：重复释放校验 ---------------
    // free()重复释放触发崩溃，此处先检查is_free状态
    if (header->is_free == 1) {
        fprintf(stderr, "Error: free_s() detected double free\n");
        return -4; // 重复释放，返回错误码
    }

    // --------------- 核心释放逻辑（与free()一致） ---------------
    // 1. 标记内存为空闲
    header->is_free = 1;

    // 2. 合并前驱空闲块
    if (header->prev != NULL && header->prev->is_free == 1) {
        SafeMemHeader* prev_header = header->prev;
        prev_header->size += header->size;
        prev_header->next = header->next;
        if (header->next != NULL) {
            header->next->prev = prev_header;
        }
        header = prev_header;
    }

    // 3. 合并后继空闲块
    if (header->next != NULL && header->next->is_free == 1) {
        SafeMemHeader* next_header = header->next;
        header->size += next_header->size;
        header->next = next_header->next;
        if (next_header->next != NULL) {
            next_header->next->prev = header;
        }
    }

    // 4. 大块内存归还给操作系统（同free()）
    SafeMemHeader* last_header = get_last_safe_mem_block();
    if (header == last_header && header->size > 1024 * 1024) { // 1MB以上
        brk(header);
        if (header->prev != NULL) {
            header->prev->next = NULL;
        }
    }

    // --------------- 差异点5：自动置NULL（关键安全特性） ---------------
    // free()无此步骤：将原指针置为NULL，消除野指针
    *ptr = NULL;

    // 返回成功码
    return 0;
}

#include <pthread.h>
#include <stdio.h>

void* shared_mem = NULL; // 多线程共享指针

// 线程B：释放共享内存
void* thread_free(void* arg) {
    // free_s()释放后，shared_mem自动置为NULL
    int ret = free_s(&shared_mem);
    if (ret == 0) {
        printf("Thread B: shared mem freed\n");
    }
    return NULL;
}

// 线程A：使用共享内存
void* thread_use(void* arg) {
    // 分配共享内存
    shared_mem = malloc(1024);
    printf("Thread A: shared mem allocated\n");

    // 等待线程B释放
    sleep(1);

    // 安全检查：free_s()后shared_mem为NULL，避免野指针访问
    if (shared_mem != NULL) {
        printf("Thread A: use shared mem\n");
        // 若用free()，此处会误用已释放内存
    } else {
        printf("Thread A: shared mem is NULL, skip use\n");
    }
    return NULL;
}

int main() {
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, thread_use, NULL);
    pthread_create(&tid2, NULL, thread_free, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

int main() {
    int* arr = malloc(10 * sizeof(int));
    free_s(arr); // 错误：传一级指针（free()可传，但free_s()不行）
    return 0;
}

free_s(&arr); // 正确：&arr是int**，可转为void**

int main() {
    int* arr = malloc(10 * sizeof(int));
    void** invalid_ptr = (void**)0x12345678; // 非法地址（野指针）
    free_s(invalid_ptr); // 错误：二级指针本身是野指针
    return 0;
}

void** valid_ptr = &arr; // 指向合法指针变量arr
free_s(valid_ptr); // 正确

// 模块A：用标准malloc分配内存
void* alloc_from_moduleA() {
    return malloc(1024); // 块头无SAFE_MEM_MAGIC
}

// 模块B：用free_s()释放模块A的内存
int main() {
    void* ptr = alloc_from_moduleA();
    int ret = free_s(&ptr); // 错误：magic值不匹配，返回-3
    return 0;
}

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

// 自定义free_s()实现（简化版，带日志）
#define SAFE_MEM_MAGIC 0x12345678
typedef struct SafeMemHeader {
    size_t size;
    int is_free;
    unsigned int magic;
    struct SafeMemHeader* next;
} SafeMemHeader;

// 安全版分配函数（配合free_s()使用）
void* malloc_s(size_t size) {
    SafeMemHeader* header = (SafeMemHeader*)malloc(size + sizeof(SafeMemHeader));
    if (header == NULL) return NULL;
    header->size = size + sizeof(SafeMemHeader);
    header->is_free = 0;
    header->magic = SAFE_MEM_MAGIC;
    header->next = NULL;
    return (void*)(header + 1); // 返回用户内存区
}

// 简化版free_s()
int free_s(void** ptr) {
    if (ptr == NULL) return -1;
    void* real_ptr = *ptr;
    if (real_ptr == NULL) return -2;

    SafeMemHeader* header = (SafeMemHeader*)real_ptr - 1;
    if (header->magic != SAFE_MEM_MAGIC) return -3;
    if (header->is_free == 1) return -4;

    header->is_free = 1;
    *ptr = NULL; // 自动置NULL
    printf("free_s(): success, ptr set to NULL\n");
    return 0;
}

// 正确案例：用malloc_s()分配，free_s()释放
void correct_case() {
    printf("\n=== Correct Case ===\n");
    int* arr = (int*)malloc_s(10 * sizeof(int));
    if (arr == NULL) {
        perror("malloc_s failed");
        return;
    }

    // 使用数组
    for (int i = 0; i < 10; i++) {
        arr[i] = i;
    }
    printf("Array before free: arr[0] = %d\n", arr[0]);

    // 对比free()：free(arr)后需手动arr=NULL，free_s()自动完成
    int ret = free_s(&arr);
    if (ret == 0) {
        printf("After free_s: arr is %s\n", arr == NULL ? "NULL" : "not NULL");
    }
}

// 错误案例1：传一级指针
void wrong_case1() {
    printf("\n=== Wrong Case 1: Pass 1st-level ptr ===\n");
    int* arr = (int*)malloc_s(10 * sizeof(int));
    int ret = free_s(arr); // 错误：传一级指针
    printf("free_s return code: %d（应返回-1或编译报错）\n", ret);
}

// 错误案例2：重复释放
void wrong_case2() {
    printf("\n=== Wrong Case 2: Double Free ===\n");
    int* arr = (int*)malloc_s(10 * sizeof(int));
    int ret1 = free_s(&arr);
    printf("1st free_s return: %d\n", ret1);
    int ret2 = free_s(&arr); // 重复释放（arr已为NULL）
    printf("2nd free_s return: %d（应返回-2）\n", ret2);
}

int main() {
    correct_case();
    wrong_case1();
    wrong_case2();
    return 0;
}

=== Correct Case ===
Array before free: arr[0] = 0
free_s(): success, ptr set to NULL
After free_s: arr is NULL

=== Wrong Case 1: Pass 1st-level ptr ===
warning: passing argument 1 of ‘free_s’ from incompatible pointer type
free_s return code: -1（应返回-1或编译报错）

=== Wrong Case 2: Double Free ===
free_s(): success, ptr set to NULL
1st free_s return: 0
Warning: free_s() target ptr is NULL（无需释放）
2nd free_s return: -2（应返回-2）

#include <string.h>

// 嵌套结构体：安全分配与释放
typedef struct SafeStudent {
    char* name; // 用malloc_s()分配
    int age;
} SafeStudent;

// 创建学生（安全分配）
SafeStudent* create_safe_student(const char* name, int age) {
    SafeStudent* stu = (SafeStudent*)malloc_s(sizeof(SafeStudent));
    if (stu == NULL) return NULL;

    stu->name = (char*)malloc_s(strlen(name) + 1);
    if (stu->name == NULL) {
        free_s(&stu); // 分配失败回滚，free_s()自动置stu为NULL
        return NULL;
    }
    strcpy(stu->name, name);
    stu->age = age;
    return stu;
}

// 释放学生（安全释放，对比free()）
void free_safe_student(SafeStudent** stu_ptr) {
    if (stu_ptr == NULL || *stu_ptr == NULL) return;

    SafeStudent* stu = *stu_ptr;
    // 对比free()：free(stu->name)后需stu->name=NULL，free_s()自动完成
    free_s(&stu->name); 
    // 释放结构体本身，自动置*stu_ptr为NULL
    free_s(stu_ptr); 
}

int main() {
    SafeStudent* stu = create_safe_student("Wang Wu", 22);
    if (stu == NULL) return 1;

    printf("Student before free: Name=%s, Age=%d\n", stu->name, stu->age);
    free_safe_student(&stu);
    printf("After free_safe_student: stu is %s\n", stu == NULL ? "NULL" : "not NULL");

    // 若用free()，需手动置NULL：
    // free(stu->name); stu->name = NULL;
    // free(stu); stu = NULL;
    return 0;
}

Student before free: Name=Wang Wu, Age=22
free_s(): success, ptr set to NULL
free_s(): success, ptr set to NULL
After free_safe_student: stu is NULL