如何从c中的文件中正确读取某些字符串？

Question

我正在尝试用 c 编写一个比较字符串的程序。字符串是成对给出的，在文件的顶部有对的数量。 该文件的格式如下：

2
a: 01010100000101011111
   01001010100000001111
   00000000000011110000
b: 00000111110000010001
   10101010100111110001
a: 00000011111111111100
   00111111111111000
b: 00000001111001010101

我的问题是正确读取字符串以便执行比较等

这是我的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>

#define NCHAR 32

int main (int argc, char **argv) {
    char *word1 = NULL;
    FILE *fp = NULL;
    for (int i = 0; i<pairs; i++){

        if (i == 0)
        {
            word1 = readWord(fp, &word1);//read a:
            while(strcmp(word1, "") == 0) word1 = readWord(fp, &word1);
        }

        word1 = readWord(fp, &word1);//read string
        while(strcmp(word1, "") == 0) word1 = readWord(fp, &word1);

        aline = malloc(amaxsize);
        strncpy(aline, word1, amaxsize);

        word1 = readWord(fp, &word1); 
        while(strcmp(word1, "") == 0) word1 = readWord(fp, &word1);

        while (strcmp(word1, "b:")!=0){
            aline = concat(aline, word1);

            word1 = readWord(fp, &word1); 
            while(strcmp(word1, "") == 0) word1 = readWord(fp, &word1);
        }

        fprintf(fpw, "a: %s\n", aline); //write to the file..
        free (word1);
        word1 = NULL;

        word1 = readWord(fp, &word1); //read string after b:
        while(strcmp(word1, "") == 0) word1 = readWord(fp, &word1);
        bline = malloc(bmaxsize);
        strncpy(bline, word1, bmaxsize);

        word1 = readWord(fp, &word1); 
        while(strcmp(word1, "") == 0) word1 = readWord(fp, &word1);

        if (i == (pairs-1))
        {

            while (strcmp(word1, "")!=0){
                bline = concat(bline, word1);
                word1 = readWord(fp, &word1);

            }
        }
        else 
        {
            while (strcmp(word1, "a:")!=0){
                bline = concat(bline, word1);
                word1 = readWord(fp, &word1);
                while(strcmp(word1, "") == 0) word1 = readWord(fp, &word1);
            }
        }
        fprintf(fpw, "b: %s\n", bline); //write to the file..
        free (word1);
        word1 = NULL;

        fprintf(fpw,"\n");
}

    char *readWord(FILE *fp, char **buffer)
    {
        int ch, nchar = NCHAR;
        int buflen = 0;
        *buffer = malloc (nchar);

        if(*buffer){
            while ((ch = fgetc(fp)) != '\n' && ch != EOF && ch != '\t' && ch != ' ') 
            {
                if (ch!='\t' && ch!= ' ' && ch != '\n') (*buffer)[buflen++] = ch;

                if (buflen + 1 >= nchar) {  /* realloc */
                    char *tmp = realloc (*buffer, nchar * 2);
                    if (!tmp) {

                        (*buffer)[buflen] = 0;

                        return *buffer;
                    }
                    *buffer = tmp;
                    nchar *= 2;
                }
            }
            (*buffer)[buflen] = 0;           /* nul-terminate */

            if (buflen == 0 && ch == EOF) {  /* return NULL if nothing read */
                free (*buffer);
                *buffer = NULL;
            }
            return *buffer;
        }
        else {
            fprintf (stderr, "Error...\n");
            return NULL;
        }
    }

readWord 函数每次读取一个单词。我要做的是用单词读取文件并将它们连接起来以获得完整的字符串 a 并将其保存在行中，以便我可以处理它。与 b 相同。问题是文件没有被正确读取，例如，我没有得到第一对的整个 a ，而是只得到它的第一部分。有什么想法吗？

Answer 1

您尝试从文件中读取的内容并不简单，但可以通过设置一个标志告诉您是否已经看到'a' 或'b'，跳过所有空格和':' 字符来相当简单地处理，将所有其他字符存储在缓冲区中，根据需要重新分配，然后在找到第二个 'a' 或 'b' 时，将该字符放回 FILE* 流中并使用 ungetc，nul 终止并返回您的缓冲区。

听起来很简单——对吧？嗯，差不多就是这样。让我们看看您的 readword() 函数需要什么。

首先，由于您在readword() 中为buffer 分配，因此无需将char **buffer 作为参数传递。您已经将readword 声明为char *readword(...)，因此只需将FILE* 指针作为参数传递，并返回一个指向您分配、填充和nul 终止 缓冲区的指针。

您可以按照自己喜欢的方式处理重新分配方案，您可以从分配的一些合理数量的字符开始，然后将当前大小加倍（或添加一些倍数），或者每次用完时添加一个固定数量.下面的示例只是从一个 32 字符的缓冲区开始，然后在每次需要重新分配时再添加一个 32 字符。 （如果数据大小真的未知，我可能会从 32 个字符开始，然后每次用完时加倍——完全取决于你）。

使用ctype.h 中的isspace() 函数可确保正确处理所有空格。

最后几个问题只是确保您在缓冲区中返回一个 nul-terminated 字符串，并确保在 @987654337 时在每个新内存块中重新初始化指向缓冲区末尾的指针@ 被调用。

总而言之，您可以执行类似于以下的操作。在readword()函数之后添加一个简单的示例程序，用于读取您的示例文件并输出从文件中读取的组合字符串，

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

#define NCHR  32

char *readword (FILE *fp)
{
    int c,                      /* current character */
        firstline = 0;          /* flag for 'a' or 'b' found at 1st char */
    size_t n = 0, nchr = NCHR;  /* chars read, number of chars allocated */
    char *buffer = NULL, *p;    /* buffer to fill, pointer to buffer */

    buffer = malloc (nchr);             /* allocate initial NCHR */
    if (!buffer) {                      /* validate */
        perror ("malloc-buffer");
        return NULL;
    }
    p = buffer;                         /* set pointer to buffer */

    while ((c = fgetc (fp)) != EOF) {   /* read each char */
        if (isspace (c) || c == ':')    /* skip all whitespace and ':' */
            continue;
        if (c == 'a' || c == 'b') {     /* begins with 'a' or 'b' */
            if (firstline) {            /* already had a/b line */
                ungetc (c, fp);         /* put the char back */
                *p = 0;                 /* nul-terminate */
                return buffer;          /* return filled buffer */
            }
            firstline = 1;              /* set firstline flag */
            continue;
        }
        else {
            if (n == nchr - 2) {        /* check if realloc needed */
                void *tmp = realloc (buffer, nchr + NCHR);
                if (!tmp)               /* validate */
                    exit (EXIT_FAILURE);
                buffer = tmp;           /* assign new block to buffer */
                p = buffer + n;         /* set p at buffer end */
                nchr += NCHR;           /* update no. chars allocated */
            }
            *p++ = c;       /* assign the current char and advance p */
            n++;            /* increment your character count */
        }
    }
    *p = 0;         /* nul-terminate */

    return buffer;
}

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

    char buf[NCHR], *word;
    int nwords, toggle = 0;
    /* use filename provided as 1st argument (stdin by default) */
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

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

    if (!fgets (buf, NCHR, fp)) {
        fputs ("error: read of line 1 failed.\n", stderr);
        return 1;
    }
    if (sscanf (buf, "%d", &nwords) != 1) {
        fputs ("error: invalid file format.\n", stderr);
        return 1;
    }
    nwords *= 2;   /* actual number of words is twice the number of pairs */

    while (nwords-- && (word = readword (fp))) {
        printf ("%c: %s\n", toggle ? 'b' : 'a', word);
        free (word);
        if (toggle) {
            putchar ('\n');
            toggle = 0;
        }
        else
            toggle = 1;
    }

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

    return 0;
}

(注意：toggle 上方只是一个1 或0 标志，用于在相应行的开头输出"a:" 或"b:" 并添加一个'\n' 读取的行对之间。）

使用/输出示例

$ ./bin/read_multiline_pairs dat/pairsbinline.txt
a: 010101000001010111110100101010000000111100000000000011110000
b: 0000011111000001000110101010100111110001

a: 0000001111111111110000111111111111000
b: 00000001111001010101

内存使用/错误检查

在动态分配存储空间时始终验证您的内存使用情况，并确保您已释放所有分配的内存。

$ valgrind ./bin/read_multiline_pairs dat/pairsbinline.txt
==14257== Memcheck, a memory error detector
==14257== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==14257== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
==14257== Command: ./bin/read_multiline_pairs dat/pairsbinline.txt
==14257==
a: 010101000001010111110100101010000000111100000000000011110000
b: 0000011111000001000110101010100111110001

a: 0000001111111111110000111111111111000
b: 00000001111001010101

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

检查一下，如果您有任何问题，请告诉我。问题的最大部分是处​​理每对所有行的读取和连接。剩下的代码留给你。