C语言逐行逐词解析文件：内存分配与strtok问题求助

一、更优实现方案 #

不需要两次遍历行统计单词数再分配内存，推荐两种高效思路：

1. 一次性解析+动态扩容 #

初始分配小容量数组，解析过程中如果空间不足就用realloc动态扩容（通常按2倍增长），全程只需遍历行一次，既避免了strtok的状态问题，又提升了效率。

示例代码：

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

#define INIT_CAPACITY 4  // 初始数组容量

// 解析一行数字，返回动态分配的数组，参数count返回元素个数
int* parse_line(char* line, int* count) {
    *count = 0;
    int capacity = INIT_CAPACITY;
    int* nums = malloc(capacity * sizeof(int));
    if (!nums) return NULL;

    char* token = strtok(line, " \n");
    while (token != NULL) {
        // 校验规则：无前导零
        if (strlen(token) > 1 && token[0] == '0') {
            free(nums);
            return NULL;
        }
        // 转换为数字并校验范围
        long num = strtol(token, NULL, 10);
        if (num > INT_MAX || num < INT_MIN) {
            free(nums);
            return NULL;
        }
        // 空间不足时扩容
        if (*count >= capacity) {
            capacity *= 2;
            int* temp = realloc(nums, capacity * sizeof(int));
            if (!temp) {
                free(nums);
                return NULL;
            }
            nums = temp;
        }
        nums[(*count)++] = (int)num;
        token = strtok(NULL, " \n");
    }
    // 可选：缩容到实际元素数量，节省内存
    int* final_nums = realloc(nums, *count * sizeof(int));
    return final_nums ? final_nums : nums;
}

2. 手动字符串解析 #

完全脱离strtok，自己遍历字符分割单词，全程可控，彻底避免strtok的静态状态问题，还能适配更复杂的分隔规则。

示例代码：

int* parse_line_manual(char* line, int* count) {
    *count = 0;
    int capacity = INIT_CAPACITY;
    int* nums = malloc(capacity * sizeof(int));
    if (!nums) return NULL;

    char* ptr = line;
    while (*ptr != '\0') {
        // 跳过空格、换行符
        while (*ptr == ' ' || *ptr == '\n') ptr++;
        if (*ptr == '\0') break;

        // 标记单词起始位置
        char* start = ptr;
        // 找到单词结束位置
        while (*ptr != ' ' && *ptr != '\n' && *ptr != '\0') ptr++;

        // 临时替换分隔符为'\0'，方便转换
        char temp = *ptr;
        *ptr = '\0';

        // 校验与转换
        if (strlen(start) > 1 && start[0] == '0') {
            free(nums);
            *ptr = temp;
            return NULL;
        }
        long num = strtol(start, NULL, 10);
        if (num > INT_MAX || num < INT_MIN) {
            free(nums);
            *ptr = temp;
            return NULL;
        }

        // 扩容检查
        if (*count >= capacity) {
            capacity *= 2;
            int* temp_ptr = realloc(nums, capacity * sizeof(int));
            if (!temp_ptr) {
                free(nums);
                *ptr = temp;
                return NULL;
            }
            nums = temp_ptr;
        }
        nums[(*count)++] = (int)num;

        // 恢复原字符
        *ptr = temp;
    }

    int* final_nums = realloc(nums, *count * sizeof(int));
    return final_nums ? final_nums : nums;
}

二、修复strtok两次调用的异常问题 #

strtok依赖静态全局变量保存解析状态，两次调用（统计单词数+解析存储）会互相覆盖状态，同时它会修改原字符串（用'\0'替换分隔符），导致第二次解析时字符串已被破坏。修复方法如下：

1. 使用可重入版本的strtok #

POSIX系统用strtok_r，Windows用strtok_s，它们通过额外的状态指针维护解析上下文，不同解析过程互不干扰。同时必须为统计和解析分别复制原始行的副本，避免原字符串被修改。

示例代码：

// 统计一行的单词数量
int count_words(char* line) {
    int count = 0;
    char* saveptr;
    char* token = strtok_r(line, " \n", &saveptr);
    while (token != NULL) {
        count++;
        token = strtok_r(NULL, " \n", &saveptr);
    }
    return count;
}

// 将一行解析到已分配的数组中
int parse_line_strtok_r(char* line, int* nums, int count) {
    char* saveptr;
    char* token = strtok_r(line, " \n", &saveptr);
    int idx = 0;
    while (token != NULL && idx < count) {
        long num = strtol(token, NULL, 10);
        nums[idx++] = (int)num;
        token = strtok_r(NULL, " \n", &saveptr);
    }
    return idx == count ? 0 : -1; // 0表示成功，-1表示解析数量不符
}

// 使用示例
void process_line(char* original_line) {
    // 第一次复制：用于统计单词数
    char* count_copy = strdup(original_line);
    if (!count_copy) return;
    int word_count = count_words(count_copy);
    free(count_copy);

    // 分配内存
    int* nums = malloc(word_count * sizeof(int));
    if (!nums) return;

    // 第二次复制：用于解析存储
    char* parse_copy = strdup(original_line);
    if (!parse_copy) {
        free(nums);
        return;
    }
    if (parse_line_strtok_r(parse_copy, nums, word_count) == 0) {
        // 这里处理解析后的nums数组
    }
    free(parse_copy);
    free(nums);
}

2. 复用strtok的注意事项 #

如果必须使用标准strtok，核心要求是：统计和解析必须使用两个独立的字符串副本，不能复用同一个字符串。因为第一次调用strtok会修改原字符串的分隔符为'\0'，第二次解析时原字符串结构已被破坏，无法正确分割单词。

内容的提问来源于stack exchange，提问作者3xhaust