【安全函数】realloc_s ()： 从 realloc 到安全增强的进化之路

int stack_var;
realloc(&stack_var, 100);  // 传入栈指针，行为未定义，可能崩溃

int* ptr = malloc(100);
ptr = realloc(ptr, 1000000000000LL);  // 若失败，ptr变为NULL，原内存泄漏

#define __STDC_WANT_LIB_EXT1__ 1  // 启用Annex K扩展
#include <stdlib.h>

errno_t realloc_s(void *ptr, rsize_t new_size, void **new_ptr);

int* arr = malloc(5 * sizeof(int));
arr = realloc(arr, 10 * sizeof(int));  // 危险：失败时arr变为NULL，内存泄漏

int* arr = NULL;
// 初始分配用calloc_s()
if (calloc_s(5, sizeof(int), &arr) != 0) { /* 错误处理 */ }

int* new_arr = arr;  // 临时保存原指针
// 调整大小，通过new_ptr输出
if (realloc_s(arr, 10 * sizeof(int), &new_arr) == 0) {
    arr = new_arr;  // 仅成功时更新指针
} else {
    // 失败时arr仍指向原内存，可继续使用
    printf("调整失败，保持原大小\n");
}

// 定义安全常量（Annex K标准）
#define RSIZE_MAX (SIZE_MAX >> 1)  // 最大安全大小（通常为SIZE_MAX/2）
#define EINVAL 22                  // 参数无效错误码
#define ENOMEM 12                  // 内存不足错误码

// 全局约束处理函数（默认终止程序）
static void (*constraint_handler)(const char* msg, void* ptr, errno_t err) = &abort;

// realloc_s()核心实现
errno_t realloc_s(void* ptr, rsize_t new_size, void** new_ptr) {
    // 步骤1：检查输出指针new_ptr是否为NULL（避免写入空指针）
    if (new_ptr == NULL) {
        (*constraint_handler)("realloc_s: new_ptr cannot be NULL", NULL, EINVAL);
        return EINVAL;
    }

    // 步骤2：处理ptr为NULL的情况（等价于malloc_s(new_size)）
    if (ptr == NULL) {
        return malloc_s(new_size, new_ptr);  // 调用安全分配函数
    }

    // 步骤3：检查new_size是否合法（0或超过RSIZE_MAX均无效）
    if (new_size == 0 || new_size > RSIZE_MAX) {
        (*constraint_handler)("realloc_s: invalid new_size", ptr, EINVAL);
        return EINVAL;
    }

    // 步骤4：验证ptr是否为安全分配函数返回的有效指针
    if (!is_valid_safe_ptr(ptr)) {  // 内部函数：检查指针合法性
        (*constraint_handler)("realloc_s: invalid pointer", ptr, EINVAL);
        return EINVAL;
    }

    // 步骤5：获取原内存块信息（大小、元数据等）
    size_t old_size = get_block_size(ptr);  // 从内存元数据中获取

    // 步骤6：若新大小≤原大小，尝试原地收缩（安全分配器支持）
    if (new_size <= old_size) {
        if (shrink_safe_block(ptr, new_size)) {  // 安全收缩函数
            *new_ptr = ptr;  // 指针不变
            return 0;
        }
        // 收缩失败则走分配新块流程
    }

    // 步骤7：需要扩展或无法原地收缩，分配新内存块
    void* temp_ptr;
    if (malloc_s(new_size, &temp_ptr) != 0) {  // 安全分配新块
        return ENOMEM;  // 分配失败，原内存仍有效
    }

    // 步骤8：复制数据（仅复制较小的大小）
    size_t copy_size = (old_size < new_size) ? old_size : new_size;
    memcpy(temp_ptr, ptr, copy_size);

    // 步骤9：释放原内存块（安全释放函数）
    free_s(ptr);

    // 步骤10：更新输出指针
    *new_ptr = temp_ptr;
    return 0;
}

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdlib.h>
#include <errno.h>

// 兼容版安全调整函数
errno_t safe_realloc(void* ptr, size_t new_size, void** new_ptr) {
#ifdef __STDC_LIB_EXT1__
    // 支持realloc_s()，直接调用
    return realloc_s(ptr, (rsize_t)new_size, new_ptr);
#else
    // 不支持，用realloc()模拟安全校验
    if (new_ptr == NULL) return EINVAL;
    if (new_size > RSIZE_MAX) return EINVAL;  // 模拟RSIZE_MAX检查
    
    void* temp = realloc(ptr, new_size);
    if (temp == NULL && new_size != 0) {
        return ENOMEM;  // 分配失败，原指针有效
    }
    *new_ptr = temp;
    return 0;
#endif
}

// 错误：用malloc()分配的指针传给realloc_s()
int* ptr = malloc(100);
int* new_ptr;
errno_t err = realloc_s(ptr, 200, &new_ptr);  // 返回EINVAL，ptr仍有效

// 正确：使用配套的安全分配函数
int* ptr;
calloc_s(10, sizeof(int), &ptr);  // 用calloc_s()分配
int* new_ptr = ptr;
err = realloc_s(ptr, 20 * sizeof(int), &new_ptr);  // 合法调用

// 自定义约束处理函数：仅警告不终止
void warn_handler(const char* msg, void* ptr, errno_t err) {
    fprintf(stderr, "安全警告：%s（错误码：%d）\n", msg, err);
    // 不调用abort()，让realloc_s()返回错误码
}

// 在程序初始化时设置
set_constraint_handler_s(warn_handler);

// 正确：realloc_s()与free_s()配对
int* ptr;
calloc_s(5, sizeof(int), &ptr);
int* new_ptr = ptr;
realloc_s(ptr, 10 * sizeof(int), &new_ptr);
free_s(new_ptr);  // 安全释放

// 错误：混用free()
free(new_ptr);  // 行为未定义，可能崩溃

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdlib.h>
#include <stdio.h>

int main() {
    size_t capacity = 4;  // 初始容量
    size_t count = 0;     // 当前元素数
    int* numbers = NULL;

    // 初始分配用calloc_s()
    if (calloc_s(capacity, sizeof(int), &numbers) != 0) {
        fprintf(stderr, "初始分配失败\n");
        return 1;
    }

    int num;
    printf("输入整数（0结束）：\n");
    while (1) {
        scanf("%d", &num);
        if (num == 0) break;

        // 容量不足时扩展为原来的2倍
        if (count >= capacity) {
            size_t new_capacity = capacity * 2;
            int* new_numbers = numbers;  // 临时保存原指针

            // 调用realloc_s()调整大小
            errno_t err = realloc_s(
                numbers, 
                new_capacity * sizeof(int), 
                &new_numbers
            );

            if (err != 0) {
                // 失败时numbers仍有效，使用原容量
                fprintf(stderr, "扩展失败（错误码：%d），保持原容量\n", err);
            } else {
                numbers = new_numbers;
                capacity = new_capacity;
                printf("已扩展至容量：%zu\n", capacity);
            }
        }

        numbers[count++] = num;
    }

    // 输出结果
    printf("输入了%d个数字：", count);
    for (size_t i = 0; i < count; i++) {
        printf("%d ", numbers[i]);
    }

    // 释放内存（用free_s()）
    free_s(numbers);
    return 0;
}

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

// 手动定义RSIZE_MAX（模拟Annex K）
#define RSIZE_MAX (SIZE_MAX >> 1)

int main() {
    size_t capacity = 4;
    size_t count = 0;
    int* numbers = calloc(capacity, sizeof(int));
    if (numbers == NULL) {
        fprintf(stderr, "初始分配失败\n");
        return 1;
    }

    int num;
    printf("输入整数（0结束）：\n");
    while (1) {
        scanf("%d", &num);
        if (num == 0) break;

        if (count >= capacity) {
            size_t new_capacity = capacity * 2;
            size_t new_size = new_capacity * sizeof(int);

            // 手动校验new_size是否合法（realloc_s()自动完成）
            if (new_size > RSIZE_MAX || new_size / sizeof(int) != new_capacity) {
                fprintf(stderr, "扩展大小无效（可能溢出）\n");
                continue;
            }

            // 调用realloc()，用临时指针接收
            int* new_numbers = realloc(numbers, new_size);
            if (new_numbers == NULL) {
                fprintf(stderr, "扩展失败，保持原容量\n");
            } else {
                numbers = new_numbers;
                capacity = new_capacity;
                printf("已扩展至容量：%zu\n", capacity);
            }
        }

        numbers[count++] = num;
    }

    // 输出并释放
    for (size_t i = 0; i < count; i++) {
        printf("%d ", numbers[i]);
    }
    free(numbers);
    return 0;
}

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// 动态字符串结构体
typedef struct {
    char* data;
    size_t length;  // 实际长度（不含'\0'）
    size_t capacity; // 容量
} SafeString;

// 初始化字符串
SafeString* sstr_init(size_t initial_capacity) {
    SafeString* s = malloc(sizeof(SafeString));
    if (s == NULL) return NULL;

    s->capacity = initial_capacity > 0 ? initial_capacity : 16;
    if (malloc_s(s->capacity, &s->data) != 0) {
        free(s);
        return NULL;
    }
    s->data[0] = '\0';
    s->length = 0;
    return s;
}

// 拼接字符串（安全版）
int sstr_append(SafeString* s, const char* str) {
    if (s == NULL || str == NULL) return -1;

    size_t str_len = strlen(str);
    size_t needed = s->length + str_len + 1;  // +1 for '\0'

    // 若容量不足，扩展至needed
    if (needed > s->capacity) {
        char* new_data = s->data;  // 保存原指针
        errno_t err = realloc_s(
            s->data, 
            needed, 
            &new_data
        );

        if (err != 0) {
            fprintf(stderr, "拼接失败（错误码：%d）\n", err);
            return -1;  // 失败时s->data仍有效
        }

        s->data = new_data;
        s->capacity = needed;
    }

    // 执行拼接
    strcat(s->data + s->length, str);
    s->length += str_len;
    return 0;
}

// 释放字符串
void sstr_free(SafeString* s) {
    if (s != NULL) {
        free_s(s->data);
        free(s);
    }
}

int main() {
    SafeString* s = sstr_init(8);
    if (s == NULL) {
        fprintf(stderr, "初始化失败\n");
        return 1;
    }

    sstr_append(s, "Hello");
    sstr_append(s, " ");
    sstr_append(s, "World!");

    printf("结果：%s（长度：%zu，容量：%zu）\n",
           s->data, s->length, s->capacity);

    sstr_free(s);
    return 0;
}

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

// 定义安全常量（跨平台）
#ifndef RSIZE_MAX
#define RSIZE_MAX (SIZE_MAX >> 1)
#endif

// 兼容版内存调整函数
errno_t cross_platform_realloc(
    void* ptr, 
    size_t new_size, 
    void** new_ptr,
    int is_safe_allocated  // 标记ptr是否由安全函数分配
) {
    // 通用参数检查
    if (new_ptr == NULL) return EINVAL;
    if (new_size > RSIZE_MAX) return EINVAL;

#ifdef __STDC_LIB_EXT1__
    // MSVC平台：使用realloc_s()（仅当ptr是安全分配的）
    if (is_safe_allocated) {
        return realloc_s(ptr, (rsize_t)new_size, new_ptr);
    }
    // 非安全分配的指针，降级为realloc()
#endif

    // GCC/Clang或非安全指针：使用realloc() + 手动处理
    void* temp = realloc(ptr, new_size);
    if (temp == NULL && new_size != 0) {
        return ENOMEM;  // 分配失败，原指针有效
    }
    *new_ptr = temp;
    return 0;
}

int main() {
    // 测试安全分配的内存调整
    void* safe_ptr = NULL;
#ifdef __STDC_LIB_EXT1__
    calloc_s(5, sizeof(int), &safe_ptr);  // 安全分配
#else
    safe_ptr = calloc(5, sizeof(int));    // 传统分配
#endif

    void* new_safe_ptr = safe_ptr;
    errno_t err = cross_platform_realloc(
        safe_ptr, 
        10 * sizeof(int), 
        &new_safe_ptr, 
        1  // 标记为安全分配
    );
    if (err == 0) {
        printf("安全内存调整成功\n");
#ifdef __STDC_LIB_EXT1__
        free_s(new_safe_ptr);
#else
        free(new_safe_ptr);
#endif
    }

    // 测试传统分配的内存调整
    void* trad_ptr = malloc(5 * sizeof(int));
    void* new_trad_ptr = trad_ptr;
    err = cross_platform_realloc(
        trad_ptr, 
        10 * sizeof(int), 
        &new_trad_ptr, 
        0  // 标记为传统分配
    );
    if (err == 0) {
        printf("传统内存调整成功\n");
        free(new_trad_ptr);
    }

    return 0;
}