使用fgets（）和strtok（）读取文本文件以分隔行中的字符串，从而产生不必要的行为

Question

我正在尝试使用fgets（）和strtok（）读取以下格式的文本文件。

1082018 1200 79 Meeting with President
2012018 1200 79 Meet with John at cinema
2082018 1400 30 games with Alpha
3022018 1200 79 sports

我需要将第一个值与该行的其余部分分开，例如：

key=21122019, val = 1200 79 Meeting with President

为此，我将strchr()用于val并将strtok()用于key ，但是，从文件读取时，key值保持不变。 我不明白为什么会这样，因为我在while循环内为in_key分配了空间，每次都在数组中的不同索引处放置。

我的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 1000 // max number of lines to be read
#define VALLEN 100
#define MAXC 1024

#define ALLOCSIZE 1000 /*size of available space*/
static char allocbuf[ALLOCSIZE]; /* storage for alloc*/
static char *allocp = allocbuf; /* next free position*/

char *alloc(int n) { /* return a pointer to n characters*/
    if (allocbuf + ALLOCSIZE - allocp >= n) { /*it fits*/
        allocp += n;
        return allocp - n; /*old p*/
    } else /*not enough room*/
        return 0;
}

int main(int argc, char** argv) {
    FILE *inp_cal;
    inp_cal = fopen("calendar.txt", "r+");

    char buf[MAXC];
    char *line[1024];
    char *p_line;

    char *in_val_arr[100];
    char *in_key_arr[100];
    int count = 0;
    char delimiter[] = " ";

    if (inp_cal) {
        printf("Processing file...\n");
        while (fgets(buf, MAXC, inp_cal)) {
            p_line = malloc(strlen(buf) + 1); // malloced with size of buffer.
            char *in_val;
            char *in_key;

            strcpy(p_line, buf);    //used to create a copy of input buffer
            line[count] = p_line;

            /* separating the line based on the first space. The words after
             * the delimeter will be copied into in_val */
            char *copy = strchr(p_line, ' ');
            if (copy) {
                if ((in_val = alloc(strlen(line[count]) + 1)) == NULL) {
                    return -1;
                } else {
                    strcpy(in_val, copy + 1);
                    printf("arr: %s", in_val);
                    in_val_arr[count] = in_val;
                }
            } else
                printf("Could not find a space\n");

            /* We now need to get the first word from the input buffer*/
            if ((in_key = alloc(strlen(line[count]) + 1)) == NULL) {
                return -1;
            }
            else {
                in_key = strtok(buf, delimiter);
                printf("%s\n", in_key);
                in_key_arr[count] = in_key; // <-- Printed out well
                count++;
            }
        }
        for (int i = 0; i < count; ++i)
            printf("key=%s, val = %s", in_key_arr[i], in_val_arr[i]); //<-- in_key_arr[i] contains same values throughout, unlike above
        fclose(inp_cal);
    }
    return 0;
}

while循环输出（正确）：

Processing file...
arr: 1200 79 Meeting with President
1082018
arr: 1200 79 Meet with John at cinema
2012018
arr: 1400 30 games with Alpha
2082018
arr: 1200 79 sports
3022018

for循环输出（不正确）：

key=21122019, val = 1200 79 Meeting with President
key=21122019, val = 1200 79 Meet with John
key=21122019, val = 1400 30 games with Alpha
key=21122019, val = 1200 79 sports

关于如何可以改进以及为什么会发生的任何建议？ 谢谢

Answer 1

继续进行注释，尝试使用strtok将数据分为key, val, somenum和该行的其余部分作为字符串，这会使事情变得比原来更难。

如果行的开头始终是：

key val somenum rest

您可以简单地使用sscanf将key, val和somenum解析为例如三个unsigned值，并将该行的其余部分解析为字符串。 为了帮助保持每个key, val, somenum和string之间的关系，将每行的值存储在struct可以极大地方便跟踪所有内容。 您甚至可以分配该string以最大程度地减少存储所需的确切数量。 例如，您可以使用如下所示的内容：

typedef struct {    /* struct to handle values */
    unsigned key, val, n;
    char *s;
} keyval_t;

然后在main()您可以分配一些初始数量的struct，保留一个索引作为计数器，使用临时的stutt和buffer循环读取每一行，然后分配字符串（以nul结尾的字符为+1 ）并复制您的结构的值。 当填充结构的数量达到你的分配量，只需realloc结构的数量和继续下去。

例如，假设您最初分配了NSTRUCT支撑并将每一行读入buf ，例如

...
#define NSTRUCT    8    /* initial struct to allocate */
#define MAXC    1024    /* read buffer size (don't skimp) */
...
    /* allocate/validate storage for max struct */
    if (!(kv = malloc (max * sizeof *kv))) {
        perror ("malloc-kv");
        return 1;
    }
    ...
    size_t ndx = 0,         /* used */
        max = NSTRUCT;      /* allocated */
    keyval_t *kv = NULL;    /* ptr to struct */
    ...
    while (fgets (buf, MAXC, fp)) { /* read each line of input */
    ...

在while循环中，您只需要使用sscanf解析值，例如

        char str[MAXC];
        size_t len;
        keyval_t tmp = {.key = 0};  /* temporary struct for parsing */
        if (sscanf (buf, "%u %u %u %1023[^\n]", &tmp.key, &tmp.val, &tmp.n,
            str) != 4) {
            fprintf (stderr, "error: invalid format, line '%zu'.\n", ndx);
            continue;
        }

随着数值解析，你检查你的指标是否达到您已经分配结构和数量realloc如果需要的话（注意使用临时指针的realloc ），例如

        if (ndx == max) {    /* check if realloc needed */
            /* always realloc with temporary pointer */
            void *kvtmp = realloc (kv, 2 * max * sizeof *kv);
            if (!kvtmp) {
                perror ("realloc-kv");
                break;  /* don't exit, kv memory still valid */
            }
            kv = kvtmp; /* assign new block to pointer */
            max *= 2;   /* increment max allocated */
        }

现在，有了struct存储，只需获取字符串的长度，将unsigned值复制到您的struct，并为kv[ndx].s分配length + 1字符，然后将str复制到kv[ndx].s ，例如

        len = strlen(str);              /* get length of str */
        kv[ndx] = tmp;                  /* assign tmp values to kv[ndx] */
        kv[ndx].s = malloc (len + 1);   /* allocate block for str */
        if (!kv[ndx].s) {               /* validate */
            perror ("malloc-kv[ndx].s");
            break;  /* ditto */
        }
        memcpy (kv[ndx++].s, str, len + 1); /* copy str to kv[ndx].s */
    }

（ 注意：如果您有strdup可以通过memcpy将malloc替换为kv[ndx].s = strdup (str); strdup但是由于strdup分配，请不要忘记检查kv[ndx].s != NULL如果您走那条路线，则在增加ndx之前）

这几乎是捕获数据的简单而强大的方法。 现在，它包含在已分配的struct数组中，您可以根据需要使用它，例如

    for (size_t i = 0; i < ndx; i++) {
        printf ("kv[%2zu] : %8u  %4u  %2u  %s\n", i,
            kv[i].key, kv[i].val, kv[i].n, kv[i].s);
        free (kv[i].s);     /* free string */
    }

    free (kv);  /* free stucts */

（不要忘记释放您分配的内存）

综上所述，您可以执行以下操作：

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

#define NSTRUCT    8    /* initial struct to allocate */
#define MAXC    1024    /* read buffer size (don't skimp) */

typedef struct {    /* struct to handle values */
    unsigned key, val, n;
    char *s;
} keyval_t;

int main (int argc, char **argv) {

    char buf[MAXC];         /* line buffer */
    size_t ndx = 0,         /* used */
        max = NSTRUCT;      /* allocated */
    keyval_t *kv = NULL;    /* ptr to struct */
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        perror ("fopen-file");
        return 1;
    }

    /* allocate/validate storage for max struct */
    if (!(kv = malloc (max * sizeof *kv))) {
        perror ("malloc-kv");
        return 1;
    }

    while (fgets (buf, MAXC, fp)) { /* read each line of input */
        char str[MAXC];
        size_t len;
        keyval_t tmp = {.key = 0};  /* temporary struct for parsing */
        if (sscanf (buf, "%u %u %u %1023[^\n]", &tmp.key, &tmp.val, &tmp.n,
            str) != 4) {
            fprintf (stderr, "error: invalid format, line '%zu'.\n", ndx);
            continue;
        }
        if (ndx == max) {    /* check if realloc needed */
            /* always realloc with temporary pointer */
            void *kvtmp = realloc (kv, 2 * max * sizeof *kv);
            if (!kvtmp) {
                perror ("realloc-kv");
                break;  /* don't exit, kv memory still valid */
            }
            kv = kvtmp; /* assign new block to pointer */
            max *= 2;   /* increment max allocated */
        }
        len = strlen(str);              /* get length of str */
        kv[ndx] = tmp;                  /* assign tmp values to kv[ndx] */
        kv[ndx].s = malloc (len + 1);   /* allocate block for str */
        if (!kv[ndx].s) {               /* validate */
            perror ("malloc-kv[ndx].s");
            break;  /* ditto */
        }
        memcpy (kv[ndx++].s, str, len + 1); /* copy str to kv[ndx].s */
    }

    if (fp != stdin)    /* close file if not stdin */
        fclose (fp);

    for (size_t i = 0; i < ndx; i++) {
        printf ("kv[%2zu] : %8u  %4u  %2u  %s\n", i,
            kv[i].key, kv[i].val, kv[i].n, kv[i].s);
        free (kv[i].s);     /* free string */
    }

    free (kv);  /* free stucts */
}

使用/输出示例

使用数据文件作为输入，您将收到以下信息：

$ ./bin/fgets_sscanf_keyval <dat/keyval.txt
kv[ 0] :  1082018  1200  79  Meeting with President
kv[ 1] :  2012018  1200  79  Meet with John at cinema
kv[ 2] :  2082018  1400  30  games with Alpha
kv[ 3] :  3022018  1200  79  sports

内存使用/错误检查

在您编写的任何可以动态分配内存的代码中，对于任何分配的内存块，您都有2个责任 ：（1） 始终保留指向该内存块起始地址的指针，因此，（2）在没有内存块时可以将其释放需要更长的时间。

必须使用一个内存错误检查程序来确保您不尝试访问内存或不在分配的块的边界之外/之外进行写入，不要尝试在未初始化的值上读取或建立条件跳转，最后确定您可以释放已分配的所有内存。

对于Linux， valgrind是通常的选择。 每个平台都有类似的内存检查器。 它们都很容易使用，只需通过它运行程序即可。

$ valgrind ./bin/fgets_sscanf_keyval <dat/keyval.txt
==6703== Memcheck, a memory error detector
==6703== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==6703== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
==6703== Command: ./bin/fgets_sscanf_keyval
==6703==
kv[ 0] :  1082018  1200  79  Meeting with President
kv[ 1] :  2012018  1200  79  Meet with John at cinema
kv[ 2] :  2082018  1400  30  games with Alpha
kv[ 3] :  3022018  1200  79  sports
==6703==
==6703== HEAP SUMMARY:
==6703==     in use at exit: 0 bytes in 0 blocks
==6703==   total heap usage: 5 allocs, 5 frees, 264 bytes allocated
==6703==
==6703== All heap blocks were freed -- no leaks are possible
==6703==
==6703== For counts of detected and suppressed errors, rerun with: -v
==6703== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

始终确认已释放已分配的所有内存，并且没有内存错误。

仔细看一下，如果还有其他问题，请让我现在。 如果您需要进一步拆分kv[i].s ，则可以考虑使用strtok 。

Answer 2

您一次又一次地将相同的指针存储在in_key_arr 。

您大致需要这样：

in_key = strtok(buf, delimiter);
printf("%s\n", in_key);
char *newkey = malloc(strlen(in_key) + 1);  // <<<< allocate new memory
strcpy(newkey, in_key);
in_key_arr[count] = newkey;                 // <<<< store newkey
count++;

免责声明：

• 为简洁起见，没有错误检查
• 完成后，需要释放已分配的内存。

Answer 3

您是通过分配给alloc分配一个地址，然后通过调用strtok来重新分配？ 改写相同的地址？ 将return从strtok复制到in_key？

       char *copy = strchr(p_line, ' ');
        if (copy) {
            if ((in_val = alloc(strlen(line[count]) + 1)) == NULL) {
                return -1;
            } else {
                printf("arr: %ul\n", in_val);
                strcpy(in_val, copy + 1);
                printf("arr: %s", in_val);
                in_val_arr[count] = in_val;
            }
        } else
            printf("Could not find a space\n");

        /* We now need to get the first word from the input buffer*/
        if ((in_key = alloc(strlen(line[count]) + 1)) == NULL) {
            return -1;
        }
        else {

            printf("key: %ul\n", in_key);
            in_key = strtok(buf, delimiter);
            printf("key:\%ul %s\n",in_key, in_key);
            in_key_arr[count++] = in_key; // <-- Printed out well
        }

输出：

allocbuf: 1433760064l
Processing file...
all: 1433760064l
arr: 1433760064l
arr: 1200 79 Meeting with President
all: 1433760104l
key: 1433760104l
key:4294956352l 1082018

此更改已解决：

strcpy(in_key, strtok(buf, delimiter));