C 问题:另一个 while 循环内的 while(fgets) 循环仅执行一次

Question

这是我正在学习的大学计算机入门类(class)。我已经被这个问题困扰了几天，我们部门的资源已经被其他学生淹没了。搜索并没有多大帮助，但我不确定我的措辞是否正确。

我正在尝试编写一个程序，从文本文件中读取单词，将它们与包含正确拼写单词列表的另一个文本文件进行比较，然后从第一个文本文件中打印不正确的单词。

我编写了一个 while(fgets) 循环来读取输入文本文件的每一行，一个 while 循环嵌套在其中将每一行标记为单独的单词，最后编写了另一个 while(fgets) 循环嵌套在其中来比较每个字典文件中每一行的标记。我看到一些问题，其中内部循环必须“重置”，但我正在使用 strtok 函数来做到这一点。

Here是指向代码要点的链接，其中包含输入文件的示例。

这是此输入的输出:

Misspelled words in words.txt :
hello, A do not match
hello, AA do not match
hello, AAA do not match
hello, thirtytwomo do not match
hello, this do not match
hello, thisaway do not match
hello, contains do not match
hello, few do not match
hello, words do not match
hello, hello match
this
contanes
a
few
words

they 
are
seperated
by
multaple

这是相关的循环:

 while (fgets(tempBuffer, sizen, instream) != NULL) {

    tempBuffer[strlen(tempBuffer) - 1] = '\0';
    //remove the endline character from the line

    char *tempToken = strtok(tempBuffer, " ");
    //tokenize the line on space:

    while (tempToken != NULL)
    //will be null at the end of each line 
    {
        char *tempCheck = malloc(sizeof(char) * (strlen(tempToken) + 1));
        //build dynamic array to hold string to check
        strcpy(tempCheck, tempToken);

        while (fgets(tempDictBuffer, sizen, dictInstream) != NULL) {
            //compares against each line in dictionary

            tempDictBuffer[strlen(tempDictBuffer) - 1] = '\0';
            //remove the endline character from the line

            char *tempDict = malloc(
                    sizeof(char) * (strlen(tempDictBuffer) + 1));
            //build dynamic array to hold string from dictionary
            strcpy(tempDict, tempDictBuffer);

            if (strcmp(tempCheck, tempDict) == 0) {
                printf("%s, %s match\n", tempCheck, tempDict);
                //if the string matches a dictionary line, this prints
                result = 1;
                //sets flag
            } else {
                printf("%s, %s do not match\n", tempCheck, tempDict);
                //if the string does not match, this prints
            }

            free(tempDict);
            tempDict = NULL;

        }
        if (result != 1) {
            printf("%s\n", tempCheck);
            //checks flag
        }
        result = 0;
        //resets flag
        free(tempCheck);
        tempCheck = NULL;
        tempToken = strtok(NULL, " ");
        //gets next token in line and reruns second while loop
    }

感谢您提供的任何帮助!

Answer 1

这有点巧合，但我碰巧有一些函数基本上可以完成您想要做的事情。它可能不是一个完美的适合，但以下读取 2 个文件，将每个文件的行加载到指向 char 的指针数组中，然后将每一行拆分为标记并比较每个相应的标记以确定拼写是否不同并输出每行的单词拼写不同。

它可能会为您提供一些关于如何解决您的问题的额外想法。 注意，这只是示例，并不代表对所有极端情况等进行了全面测试。由于您动态分配存储，因此有助于继续使用该方法来标记每行。一个函数将完全标记每一行并将单词返回到 char 指针数组中，从而大大减少所需的嵌套循环的数量和类型。至于它的值(value)如何，请看一下。另请注意，下面的代码中未使用 prn_chararray 函数，但为了方便而保留:

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

#define NMAX 256
#define BUFL 64
#define MAXS 32

char **readtxtfile (char *fn, size_t *idx);
char **splitstr (char *s, size_t *n);
char **realloc_char (char **p, size_t *n);
void prn_chararray (char **ca);
void free_chararray (char **ca);

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

    if (argc < 3 ) {
        fprintf (stderr, "error: insufficient input, usage: %s <filename1> <filename2>\n", argv[0]);
        return 1;
    }

    size_t file1_size = 0;  /* placeholders to be filled by readtxtfile */
    size_t file2_size = 0;  /* for general use, not needed to iterate   */
    size_t i = 0;           /* general counter/iterator                 */
    size_t linemin = 0;     /* minimum of comparison lines in file1/2   */

    /* read each file into an array of strings,
       number of lines read, returned in file_size */
    char **file1 = readtxtfile (argv[1], &file1_size);
    char **file2 = readtxtfile (argv[2], &file2_size);

    linemin = file1_size < file2_size ? file1_size : file2_size;

    for (i = 0; i < linemin; i++)
    {
        size_t nwords1 = 0;     /* number of words read file1 line          */
        size_t nwords2 = 0;     /* number of words read file2 line          */
        size_t wordmin = 0;     /* minimum number of words in file1/2 lines */
        size_t j = 0;           /* general counter/iterator                 */

        printf ("\n file1[%2zu] : %s\n file2[%2zu] : %s\n\n", i, file1[i], i, file2[i]);

        char **f1words = splitstr (file1[i], &nwords1);
        char **f2words = splitstr (file2[i], &nwords2);

        if (!f1words || !f2words) {
            fprintf (stderr, "error: word splitting falure.\n");
            continue;
        }

        wordmin = nwords1 < nwords2 ? nwords1 : nwords2;
        for (j = 0; j < wordmin; j++)
        {
            if (strcmp (f1words[j], f2words[j]))
                printf ("  %16s  !=  %s\n", f1words[j], f2words[j]);
        }

        free_chararray (f1words);
        free_chararray (f2words);

        f1words = NULL;
        f2words = NULL;
    }

    /* simple free memory function */
    if (file1) free_chararray (file1);
    if (file2) free_chararray (file2);

    return 0;
}

char** readtxtfile (char *fn, size_t *idx)
{
    if (!fn) return NULL;           /* validate filename provided       */

    char *ln = NULL;                /* NULL forces getline to allocate  */
    size_t n = 0;                   /* max chars to read (0 - no limit) */
    ssize_t nchr = 0;               /* number of chars actually read    */
    size_t nmax = NMAX;             /* check for reallocation           */
    char **array = NULL;            /* array to hold lines read         */
    FILE *fp = NULL;                /* file pointer to open file fn     */

    /* open / validate file */
    if (!(fp = fopen (fn, "r"))) {
        fprintf (stderr, "%s() error: file open failed '%s'.", __func__, fn);
        return NULL;
    }

    /* allocate NMAX pointers to char* */
    if (!(array = calloc (NMAX, sizeof *array))) {
        fprintf (stderr, "%s() error: memory allocation failed.", __func__);
        return NULL;
    }

    /* read each line from stdin - dynamicallly allocated   */
    while ((nchr = getline (&ln, &n, fp)) != -1)
    {
        /* strip newline or carriage rtn    */
        while (nchr > 0 && (ln[nchr-1] == '\n' || ln[nchr-1] == '\r'))
            ln[--nchr] = 0;

        array[*idx] = strdup (ln);  /* allocate/copy ln to array        */

        (*idx)++;                   /* increment value at index         */

        if (*idx == nmax)           /* if lines exceed nmax, reallocate */
            array = realloc_char (array, &nmax);
    }

    if (ln) free (ln);              /* free memory allocated by getline */
    if (fp) fclose (fp);            /* close open file descriptor       */

    return array;
}

/* split string 's' into separate words including break on
space as well as non-printing and format characters
return pointer to array of pointers to strings 'a' and
number of words in 'n' */
char **splitstr (char *s, size_t *n)
{
    if (!s || !*s ) return NULL;

    char *p = s;                            /* pointer to char          */
    char buf[BUFL] = {0};                   /* temporary buffer         */
    char *bp = buf;                         /* pointer to buf           */
    size_t maxs = MAXS;                     /* check for reallocation   */
    *n = 0;                                 /* index number of tokens   */

    /* allocate and validate array of pointer to char */
    char **a = calloc (MAXS, sizeof *a);
    if (!a) {
        fprintf (stderr, "%s() error: memory allocation failed.\n", __func__);
        return NULL;
    }

    while (*p)                              /* for each char in string1 */
    {
        /* skip each non-print/format char */
        while (*p && (*p <= ' ' || *p > '~'))
            p++;

        if (!*p) break;                     /* break if end reached     */

        while (*p > ' ' && *p <= '~')       /* for each printable char  */
        {
            *bp = *p++;                     /* copy to strings buffer   */
            bp++;                           /* advance to nex position  */
        }

        *bp = 0;                            /* null-terminate strings   */
        a[*n] = strdup (buf);               /* alloc/copy buf to a[*n]  */
        (*n)++;                             /* next index in strings    */

        if (*n == maxs)                     /* check if *n exceeds maxs */
            a = realloc_char (a, &maxs);    /* realloc if a if reqd     */

        bp = buf;                           /* reset bp to start of buf */
    }

    return a;
}

/* print an array of character pointers. */
void prn_chararray (char **ca)
{
    register size_t n = 0;
    while (ca[n])
    {
        printf (" arr[%3zu]  %s\n", n, ca[n]);
        n++;
    }
}

/* free array of char* */
void free_chararray (char **ca)
{
    if (!ca) return;
    register size_t n = 0;
    while (ca[n])
        free (ca[n++]);
    free (ca);
}

/*  realloc an array of pointers to strings setting memory to 0.
 *  reallocate an array of character arrays setting
 *  newly allocated memory to 0 to allow iteration
 */
char **realloc_char (char **p, size_t *n)
{
#ifdef DEBUG
    printf ("\n  reallocating %zu to %zu (size: %lu)\n", *n, *n * 2, 2 * *n * sizeof *p);
#endif
    char **tmp = realloc (p, 2 * *n * sizeof *p);
    if (!tmp) {
        fprintf (stderr, "%s() error: reallocation failure.\n", __func__);
        // return NULL;
        exit (EXIT_FAILURE);
    }
    p = tmp;
    memset (p + *n, 0, *n * sizeof *p); /* memset new ptrs 0 */
    *n *= 2;

    return p;
}

输入文件

$ cat dat/words1.txt
Eye have a spelling chequer,
It came with my Pea Sea.
It plane lee marks four my revue,
Miss Steaks I can knot sea.
Eye strike the quays and type a whirred,
And weight four it two say,
Weather eye am write oar wrong,
It tells me straight aweigh.
Eye ran this poem threw it,
Your shore real glad two no.
Its vary polished in its weigh.
My chequer tolled me sew.
A chequer is a bless thing,
It freeze yew lodes of thyme.
It helps me right all stiles of righting,
And aides me when eye rime.
Each frays come posed on my screen,
Eye trussed too bee a joule.
The chequer pours over every word,
Two cheque sum spelling rule.

$ cat dat/words2.txt
I have a spelling checker,
It came with my Pin See.
It plainly skips marks for my revue,
Mistakes skip I can not see.
I strike the keys and type a word,
And wait for it to say,
Whether I am right or wrong,
It tells me straight away.
I ran this poem through it,
Your are real glad too no.
Its very polished in its way.
My checker told me so.
A checker is a blessed thing,
It frees you lots of time.
It helps me write all styles of writing,
And helps me when I rhyme.
Each pharse composed up on my screen,
I trust too bee a jewel.
The checker pours over every word,
Two check some spelling rule.

输出

$ ./bin/getline_cmplines dat/words1.txt dat/words2.txt

 file1[ 0] : Eye have a spelling chequer,
 file2[ 0] : I have a spelling checker,

               Eye  !=  I
          chequer,  !=  checker,

 file1[ 1] : It came with my Pea Sea.
 file2[ 1] : It came with my Pin See.

               Pea  !=  Pin
              Sea.  !=  See.

 file1[ 2] : It plane lee marks four my revue,
 file2[ 2] : It plainly skips marks for my revue,

             plane  !=  plainly
               lee  !=  skips
              four  !=  for

 file1[ 3] : Miss Steaks I can knot sea.
 file2[ 3] : Mistakes skip I can not see.

              Miss  !=  Mistakes
            Steaks  !=  skip
              knot  !=  not
              sea.  !=  see.

 file1[ 4] : Eye strike the quays and type a whirred,
 file2[ 4] : I strike the keys and type a word,

               Eye  !=  I
             quays  !=  keys
          whirred,  !=  word,

 file1[ 5] : And weight four it two say,
 file2[ 5] : And wait for it to say,

            weight  !=  wait
              four  !=  for
               two  !=  to

 file1[ 6] : Weather eye am write oar wrong,
 file2[ 6] : Whether I am right or wrong,

           Weather  !=  Whether
               eye  !=  I
             write  !=  right
               oar  !=  or
<snip>

泄漏检查

$ valgrind ./bin/getline_cmplines dat/words1.txt dat/words2.txt
==5670== Memcheck, a memory error detector
==5670== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==5670== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==5670== Command: ./bin/getline_cmplines dat/words1.txt dat/words2.txt
==5670==

 file1[ 0] : Eye have a spelling chequer,
 file2[ 0] : I have a spelling checker,

               Eye  !=  I
          chequer,  !=  checker,

<snip>

==5670==
==5670== HEAP SUMMARY:
==5670==     in use at exit: 0 bytes in 0 blocks
==5670==   total heap usage: 330 allocs, 330 frees, 18,138 bytes allocated
==5670==
==5670== All heap blocks were freed -- no leaks are possible
==5670==
==5670== For counts of detected and suppressed errors, rerun with: -v
==5670== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)