【安全函数】C语言字符串复制的安全升级：strcpy_s () 与 strncpy_s () 全方位解析及对比

errno_t strcpy_s(char *restrict dest, rsize_t destsz, const char *restrict src);

errno_t strncpy_s(char *restrict dest, rsize_t destsz, const char *restrict src, rsize_t count);

errno_t strcpy_s(char *restrict dest, rsize_t destsz, const char *restrict src) {
    // 1. 参数合法性检查
    if (dest == NULL) {
        if (destsz != 0) return EINVAL; // dest为NULL时destsz必须为0
        else return 0; // 特殊情况：dest为NULL且destsz为0
    }
    if (src == NULL || destsz > RSIZE_MAX) {
        return EINVAL; // 源字符串为NULL或缓冲区大小超限
    }
    
    // 2. 计算源字符串长度（包括'\0'）
    size_t src_len = strlen(src) + 1; // +1是因为strlen不包含'\0'
    
    // 3. 检查目标缓冲区是否足够
    if (src_len > destsz) {
        // 缓冲区不足：设置目标为_empty字符串并返回错误
        if (destsz > 0) {
            *dest = '\0'; // 确保目标是合法空字符串
        }
        return ERANGE;
    }
    
    // 4. 执行复制（确保无内存重叠）
    memcpy(dest, src, src_len); // 使用memcpy确保高效复制
    
    // 5. 返回成功
    return 0;
}

errno_t strncpy_s(char *restrict dest, rsize_t destsz, const char *restrict src, rsize_t count) {
    // 1. 参数合法性检查
    if (dest == NULL) {
        if (destsz != 0) return EINVAL;
        else return 0;
    }
    if (src == NULL || destsz > RSIZE_MAX || count > RSIZE_MAX) {
        return EINVAL;
    }
    if (destsz == 0) {
        return 0; // 缓冲区大小为0时无操作
    }
    
    // 2. 确定实际需要复制的字符数
    size_t src_available = strlen(src); // 源字符串长度（不含'\0'）
    size_t copy_len = (src_available < count) ? src_available : count;
    
    // 3. 检查是否有足够空间存放复制的字符加'\0'
    if (copy_len + 1 > destsz) {
        // 空间不足：设置目标为空字符串并返回错误
        *dest = '\0';
        return ERANGE;
    }
    
    // 4. 复制指定长度的字符
    memcpy(dest, src, copy_len);
    
    // 5. 强制添加'\0'（关键：确保目标字符串合法）
    dest[copy_len] = '\0';
    
    // 6. 返回成功
    return 0;
}

#define BUFFER_SIZE 100
char dest[BUFFER_SIZE];
const char *src = "需要完整复制的字符串";

// 安全复制：若src太长会返回错误
errno_t err = strcpy_s(dest, BUFFER_SIZE, src);
if (err != 0) {
    // 错误处理：如记录日志、提示用户
    printf("复制失败，错误码：%d\n", err);
}

#define INPUT_BUFFER 256
char user_input[INPUT_BUFFER];
char processed[128];

// 读取用户输入
fgets(user_input, INPUT_BUFFER, stdin);

// 安全复制到较小的缓冲区
errno_t err = strcpy_s(processed, sizeof(processed), user_input);
if (err == ERANGE) {
    printf("输入过长，已截断处理\n");
    // 可执行截断处理逻辑
}

#define MAX_DISPLAY 20
char short_str[MAX_DISPLAY];
const char *long_str = "这是一个可能很长的字符串，需要截断显示";

// 最多复制19个字符（留1个给'\0'）
errno_t err = strncpy_s(short_str, sizeof(short_str), long_str, MAX_DISPLAY - 1);
if (err == 0) {
    printf("截断后：%s\n", short_str); // 确保以'\0'结尾
}

#define PROTOCOL_FIELD_LEN 32
char protocol_field[PROTOCOL_FIELD_LEN];
const char *data = "需要放入协议字段的数据";

// 复制最多31个字符，确保字段合法
errno_t err = strncpy_s(protocol_field, PROTOCOL_FIELD_LEN, data, PROTOCOL_FIELD_LEN - 1);
if (err != 0) {
    // 处理错误：如使用默认值
    strcpy_s(protocol_field, PROTOCOL_FIELD_LEN, "default");
}

// 跨平台兼容代码示例
#ifdef __STDC_WANT_LIB_EXT1__
    // 使用安全函数
    #define safe_strcpy(dest, destsz, src) strcpy_s(dest, destsz, src)
#else
    // 传统函数的安全封装（需自行实现）
    #define safe_strcpy(dest, destsz, src) do { \
        if (strlen(src) + 1 <= destsz) { \
            strcpy(dest, src); \
        } else { \
            // 错误处理 \
        } \
    } while(0)
#endif

// 错误示例：忽略错误码
strcpy_s(dest, 5, "太长的字符串"); // 会返回ERANGE，但未处理
printf("%s", dest); // 此时dest已被设置为空字符串，行为可预测

// 正确示例：处理错误码
errno_t err = strcpy_s(dest, 5, "太长的字符串");
if (err == ERANGE) {
    printf("错误：字符串太长，无法复制\n");
    // 执行恢复逻辑
}

char dest[10];
// 错误：使用strlen(dest)而非sizeof(dest)，此时dest未初始化，长度未知
strcpy_s(dest, strlen(dest), "test");

// 正确：使用sizeof获取缓冲区大小
strcpy_s(dest, sizeof(dest), "test");

char dest[10];
// 错误：count未预留'\0'空间，可能导致ERANGE
strncpy_s(dest, sizeof(dest), "long string", 10);

// 正确：count最多为缓冲区大小-1
strncpy_s(dest, sizeof(dest), "long string", sizeof(dest)-1);

const char *dest = "不能修改的字符串"; // 字符串常量不可修改
// 错误：尝试向const指针复制
strcpy_s(dest, 10, "test"); // 编译错误或运行时错误

#define BUFFER_SIZE 100
char buffer[BUFFER_SIZE];
const char *input = get_external_data(); // 获取外部数据

// 组合使用安全函数
if (input != NULL) {
    // 先检查源字符串长度是否合理
    size_t input_len = strnlen_s(input, BUFFER_SIZE); // 安全获取长度
    
    // 再进行复制
    errno_t err = strcpy_s(buffer, BUFFER_SIZE, input);
    if (err != 0) {
        // 错误处理
    }
}

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

// 启用安全函数（部分编译器需要）
#define __STDC_WANT_LIB_EXT1__ 1

int main() {
    // 测试场景1：源字符串长度合适
    char dest1[20];
    const char *src1 = "合适长度的字符串";
    
    // 使用strcpy()
    strcpy(dest1, src1);
    printf("strcpy() 成功: %s\n", dest1);
    
    // 使用strcpy_s()
    errno_t err = strcpy_s(dest1, sizeof(dest1), src1);
    if (err == 0) {
        printf("strcpy_s() 成功: %s\n", dest1);
    }
    
    // 测试场景2：源字符串过长
    char dest2[10];
    const char *src2 = "这是一个过长的字符串";
    
    // 使用strcpy()（危险！可能导致缓冲区溢出）
    printf("strcpy() 过长测试: ");
    strcpy(dest2, src2); // 未定义行为，可能崩溃或输出乱码
    printf("%s (可能已溢出)\n", dest2);
    
    // 使用strcpy_s()（安全处理）
    printf("strcpy_s() 过长测试: ");
    err = strcpy_s(dest2, sizeof(dest2), src2);
    if (err == ERANGE) {
        printf("错误: 字符串太长，dest2已被清空: %s\n", dest2); // dest2为空字符串
    }
    
    // 测试场景3：空指针处理
    char *dest3 = NULL;
    const char *src3 = "测试空指针";
    
    // 使用strcpy()（危险！空指针访问，可能崩溃）
    printf("strcpy() 空指针测试: ");
    // strcpy(dest3, src3); // 会导致运行时错误
    
    // 使用strcpy_s()（安全处理）
    printf("strcpy_s() 空指针测试: ");
    err = strcpy_s(dest3, 0, src3); // dest为NULL时destsz必须为0
    if (err == 0) {
        printf("正确处理空指针\n");
    } else {
        printf("错误码: %d\n", err);
    }
    
    return 0;
}

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

#define __STDC_WANT_LIB_EXT1__ 1

int main() {
    // 测试场景1：源字符串短于count
    char dest1[15];
    const char *src1 = "短字符串";
    size_t count1 = 10;
    
    // 使用strncpy()
    strncpy(dest1, src1, count1);
    // strncpy()不会自动添加'\0'，需手动处理
    dest1[count1] = '\0'; // 若不添加，可能不是合法字符串
    printf("strncpy() 短字符串: %s\n", dest1);
    
    // 使用strncpy_s()
    errno_t err = strncpy_s(dest1, sizeof(dest1), src1, count1);
    if (err == 0) {
        printf("strncpy_s() 短字符串: %s\n", dest1); // 自动添加'\0'
    }
    
    // 测试场景2：源字符串长于count
    char dest2[10];
    const char *src2 = "这是一个较长的字符串";
    size_t count2 = 8;
    
    // 使用strncpy()
    strncpy(dest2, src2, count2);
    // 源字符串较长，strncpy()不会添加'\0'，导致字符串不合法
    printf("strncpy() 长字符串: %s (可能乱码)\n", dest2); // 无'\0'，输出乱码
    
    // 使用strncpy_s()
    err = strncpy_s(dest2, sizeof(dest2), src2, count2);
    if (err == 0) {
        // 自动添加'\0'，确保字符串合法
        printf("strncpy_s() 长字符串: %s\n", dest2);
    }
    
    // 测试场景3：缓冲区大小不足
    char dest3[5];
    const char *src3 = "测试";
    size_t count3 = 10;
    
    // 使用strncpy()（危险！会导致溢出）
    strncpy(dest3, src3, count3); // 复制count3字节，超过缓冲区大小
    printf("strncpy() 缓冲区不足: %s (可能溢出)\n", dest3);
    
    // 使用strncpy_s()（安全处理）
    err = strncpy_s(dest3, sizeof(dest3), src3, count3);
    if (err == ERANGE) {
        printf("strncpy_s() 缓冲区不足: 错误码%d，dest3已清空: %s\n", err, dest3);
    }
    
    return 0;
}

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

#define __STDC_WANT_LIB_EXT1__ 1
#define MAX_USERNAME 20
#define MAX_EMAIL 50

// 安全读取用户输入并处理
int read_user_input(char *username, size_t uname_size, 
                   char *email, size_t email_size) {
    char temp[1024]; // 临时缓冲区
    
    // 读取用户名
    printf("请输入用户名（最多%d个字符）: ", (int)(uname_size - 1));
    if (fgets(temp, sizeof(temp), stdin) == NULL) {
        printf("输入错误\n");
        return -1;
    }
    // 移除换行符
    temp[strcspn(temp, "\n")] = '\0';
    
    // 安全复制到用户名缓冲区
    errno_t err = strcpy_s(username, uname_size, temp);
    if (err == ERANGE) {
        printf("用户名过长，最多%d个字符\n", (int)(uname_size - 1));
        return -1;
    } else if (err != 0) {
        printf("处理用户名错误\n");
        return -1;
    }
    
    // 读取邮箱
    printf("请输入邮箱（最多%d个字符）: ", (int)(email_size - 1));
    if (fgets(temp, sizeof(temp), stdin) == NULL) {
        printf("输入错误\n");
        return -1;
    }
    temp[strcspn(temp, "\n")] = '\0';
    
    // 安全复制到邮箱缓冲区（限制长度）
    err = strncpy_s(email, email_size, temp, email_size - 1);
    if (err != 0) {
        printf("邮箱格式错误\n");
        return -1;
    }
    
    return 0;
}

int main() {
    char username[MAX_USERNAME];
    char email[MAX_EMAIL];
    
    if (read_user_input(username, MAX_USERNAME, email, MAX_EMAIL) == 0) {
        printf("\n注册信息:\n");
        printf("用户名: %s\n", username);
        printf("邮箱: %s\n", email);
    }
    
    return 0;
}