【安全函数】Windows 安全分割利器：strtok_s () 详解

#include <string.h>
// 若使用MinGW-w64，需定义宏以启用扩展（可选）
#define __STDC_WANT_LIB_EXT1__ 1

char *strtok_s(
    char *str,          // 目标字符串（首次调用传非NULL，后续传NULL）
    const char *delim,  // 分隔符集合（同strtok()）
    char **context      // 上下文指针（保存分割状态，用户需初始化）
);

char *strtok_s(
    char *restrict str,          // 目标字符串（restrict表无别名）
    rsize_t *restrict maxcount,  // 字符串最大长度指针（防止溢出）
    const char *restrict delim,  // 分隔符集合
    char **restrict context      // 上下文指针
);

// 微软扩展版strtok_s()伪代码（无maxcount参数）
char *strtok_s(char *str, const char *delim, char **context) {
    // 安全校验1：context必须非NULL（状态必须由用户管理）
    if (context == NULL) {
        return NULL;  // 非法参数，返回NULL
    }

    char *current_ptr;  // 当前分割位置
    char *token_start;  // 子串起始地址

    // 步骤1：初始化分割位置（首次调用vs后续调用）
    if (str != NULL) {
        // 首次调用：从str起始位置开始，重置context
        current_ptr = str;
    } else {
        // 后续调用：从context记录的位置开始
        current_ptr = *context;
        // 安全校验2：若context指向末尾，分割结束
        if (current_ptr == NULL || *current_ptr == '\0') {
            return NULL;
        }
    }

    // 步骤2：跳过当前位置的所有分隔符（处理连续分隔符）
    while (*current_ptr != '\0') {
        int is_delim = 0;
        const char *d = delim;
        // 检查当前字符是否在分隔符集合中
        while (*d != '\0') {
            if (*current_ptr == *d) {
                is_delim = 1;
                break;
            }
            d++;
        }
        if (!is_delim) {
            break;  // 找到非分隔符，停止跳过
        }
        current_ptr++;  // 是分隔符，继续向后
    }

    // 步骤3：若跳过分隔符后已到末尾，返回NULL
    if (*current_ptr == '\0') {
        *context = current_ptr;  // 更新context为末尾，避免下次误判
        return NULL;
    }

    // 步骤4：标记子串起始位置，寻找下一个分隔符
    token_start = current_ptr;
    while (*current_ptr != '\0') {
        int is_delim = 0;
        const char *d = delim;
        while (*d != '\0') {
            if (*current_ptr == *d) {
                is_delim = 1;
                break;
            }
            d++;
        }
        if (is_delim) {
            // 步骤5：替换分隔符为'\0'，标记子串结束
            *current_ptr = '\0';
            // 更新context为下一个分割位置
            *context = current_ptr + 1;
            return token_start;  // 返回当前子串
        }
        current_ptr++;
    }

    // 步骤6：遍历至字符串末尾（无更多分隔符）
    *context = current_ptr;  // context指向'\0'
    return token_start;
}

// 安全校验3：防止缓冲区溢出（C11版特有）
if (current_ptr - str >= *maxcount) {
    *context = NULL;
    return NULL;
}

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

// 线程参数：包含待分割字符串和独立context
typedef struct {
    char str[128];  // 待分割字符串（复制后传入，避免原串修改）
    char *ctx;      // 线程独立的context
} ThreadParam;

// 线程函数：分割字符串并输出结果
DWORD WINAPI SplitThread(LPVOID lpParam) {
    ThreadParam *param = (ThreadParam *)lpParam;
    const char *delim = ";";

    printf("线程%d开始分割：%s\n", GetCurrentThreadId(), param->str);
    // 首次调用：传入str和context
    char *token = strtok_s(param->str, delim, &param->ctx);
    while (token != NULL) {
        printf("线程%d子串：%s\n", GetCurrentThreadId(), token);
        // 后续调用：传入NULL
        token = strtok_s(NULL, delim, &param->ctx);
        Sleep(500);  // 模拟耗时操作，验证线程安全
    }
    printf("线程%d分割结束\n", GetCurrentThreadId());
    return 0;
}

int main() {
    // 线程1参数："cmd=login;user=test"
    ThreadParam param1;
    strcpy_s(param1.str, sizeof(param1.str), "cmd=login;user=test");
    param1.ctx = NULL;

    // 线程2参数："cmd=query;id=123"
    ThreadParam param2;
    strcpy_s(param2.str, sizeof(param2.str), "cmd=query;id=123");
    param2.ctx = NULL;

    // 创建线程
    HANDLE hThread1 = CreateThread(NULL, 0, SplitThread, &param1, 0, NULL);
    HANDLE hThread2 = CreateThread(NULL, 0, SplitThread, &param2, 0, NULL);

    // 等待线程结束
    WaitForSingleObject(hThread1, INFINITE);
    WaitForSingleObject(hThread2, INFINITE);

    // 释放资源
    CloseHandle(hThread1);
    CloseHandle(hThread2);
    return 0;
}

#include <stdio.h>
#include <string.h>
#define __STDC_WANT_LIB_EXT1__ 1  // 启用C11边界检查扩展

int main() {
    char input[64];  // 固定缓冲区，防止输入过长
    rsize_t max_len = sizeof(input);  // 最大长度（C11版参数）
    char *ctx = NULL;
    const char *delim = ",";

    printf("请输入「姓名,年龄,性别」（不超过63字符）：");
    // 安全读取用户输入（避免缓冲区溢出）
    if (fgets_s(input, sizeof(input), stdin) == NULL) {
        printf("输入错误\n");
        return -1;
    }

    // 去除fgets_s读取的换行符
    input[strcspn(input, "\n")] = '\0';

    // C11版strtok_s：传入max_len，防止越界
    char *token = strtok_s(input, &max_len, delim, &ctx);
    while (token != NULL) {
        printf("解析结果：%s\n", token);
        token = strtok_s(NULL, &max_len, delim, &ctx);
    }

    return 0;
}

#ifdef _WIN32
// Windows：使用strtok_s
#define STRTOK(str, delim, ctx) strtok_s(str, delim, ctx)
#else
// 类Unix：使用strtok_r（C标准可重入版）
#define STRTOK(str, delim, ctx) strtok_r(str, delim, ctx)
#endif

// 统一调用接口
char *ctx = NULL;
char *token = STRTOK("a,b,c", ",", &ctx);

char *ctx = NULL;
// 分割第一个字符串
strtok_s("a,b,c", ",", &ctx);
// 错误：复用同一ctx分割第二个字符串，状态残留
strtok_s("x,y,z", ",", &ctx);  // 可能返回错误结果

char *ctx1 = NULL;
strtok_s("a,b,c", ",", &ctx1);  // 第一个字符串的context

char *ctx2 = NULL;
strtok_s("x,y,z", ",", &ctx2);  // 第二个字符串的context（独立）

const char original[] = "a,,b;c";  // 原串（const，不可修改）
char str[64];
// Windows安全复制（避免strcpy的溢出风险）
strcpy_s(str, sizeof(str), original);

char *ctx = NULL;
char *token = strtok_s(str, ",;", &ctx);  // 分割复制后的str，不影响original

rsize_t len = 10;
char *ctx = NULL;
// 错误：微软版无maxcount参数，编译报错
strtok_s("a,b,c", &len, ",", &ctx);

char *ctx;  // 未初始化（可能是随机值）
strtok_s(NULL, ",", &ctx);  // 非法调用，可能崩溃

char input[64];
// 错误：用gets()读取输入，可能溢出
// gets(input);
// 正确：用fgets_s()安全读取
fgets_s(input, sizeof(input), stdin);

#ifdef _WIN32
// Windows：使用strtok_s
#define SAFE_STRTOK(str, delim, ctx) strtok_s(str, delim, ctx)
#else
// 类Unix：使用strtok_r（参数顺序与strtok_s一致）
#define SAFE_STRTOK(str, delim, ctx) strtok_r(str, delim, ctx)
#endif

// 统一调用
char *ctx = NULL;
char str[] = "a,b,c,d";
char *token = SAFE_STRTOK(str, ",", &ctx);
while (token != NULL) {
    printf("%s ", token);
    token = SAFE_STRTOK(NULL, ",", &ctx);
}

char *ctx = NULL;
// 分割第一个字符串
strtok_s("a,b,c", ",", &ctx);
// 错误：复用ctx分割第二个字符串，状态混乱
strtok_s("x,y,z", ",", &ctx);

正确示例（独立context）：  
char *ctx1 = NULL;
strtok_s("a,b,c", ",", &ctx1);  // 第一个字符串的context

char *ctx2 = NULL;
strtok_s("x,y,z", ",", &ctx2);  // 第二个字符串的context（独立）