确定文件中字符串的长度

Question

考虑文件中的以下3行：

This is the first line of a text.
Second line comes next.
File ends here.

我想阅读这些行并将其存储在数组中。 问题是我不知道他们是为了多长时间malloc所需的空间。

在给出示例的情况下，它们的长度很小，但是请考虑也有很大的线。

我不想malloc 1000个字节 ，并将其定义字符串作为最大长度。 那么，有没有办法，我可以找出每行的长度，以malloc适当的空间？

注意：我已经考虑过使用realloc但是当字符串很长时，这不是一个不好的技术吗？

Answer 1

首先动态分配一些内存，这些内存将表示文件上一行的平均长度。 无论是什么-现在逐char读取char然后，当您到达malloc内存（ malloc ）的末尾时，请使用realloc重新分配（ realloc将大小增加一倍）。 然后，在找到\\n -再次重新分配以释放您要求但本行不需要的那些额外内存。 这样，您可以读取整行，然后可以拥有用于存储每一行​​的必要内存（通过使用malloc ， realloc ）。

并回答有关如果这是不够好，您的评论-这里的数量realloc可以通过使分配一大块第一次，然后填充它，因为你需要收缩后它可以大大减少。 是的，多次执行会占用大量性能，但是我们每次都会加倍。 因此，除非初始大小太小-否则不适合。

还有getline可以为您完成困难的工作，但是是的，这是POSIX的一部分，因此使用它不会为您带来可移植性。 您可以查看此处提供的小示例，以了解如何使用它。

Answer 2

从文件中读取未知长度的未知数量的行的标准方法-并且仅分配所需的存储，是最初分配一些合理预期的指针数量（使用指向字符的指针 ，例如double终场， char **lines; ），然后读取和分配用于各条线和分配的存储器地址将线路保持为所分配的指针以顺序的方式，直到到达您已经分配指针的数量的限制，则然后realloc指针的数量（通常是当前指针的两倍）并继续前进，请根据需要重复。

尽管可以使用fgets ，但如果有POSIX getline可用，它将使用其内部分配来处理任何行的读取，而不管其长度如何，这是分配行的副本并将该地址分配给下一个指针的唯一工作之一。 strdup使它很简单，但如果没有，则getline返回它已读取的字符数（例如nchr = getline (&line, &n, fp);使之成为char *buf = malloc (nchr + 1); strcpy (buf, line);的简单任务char *buf = malloc (nchr + 1); strcpy (buf, line); ）在strdup不可用的情况下。

一个简短的示例，包括必要的验证，将是：

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

#define NPTR 8

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

    size_t ndx = 0,             /* line index */
        nptrs = NPTR,           /* initial number of pointers */
        n = 0;                  /* line alloc size (0, getline decides) */
    ssize_t nchr = 0;           /* return (no. of chars read by getline) */
    char *line = NULL,          /* buffer to read each line */
        **lines = NULL;         /* pointer to pointer to each line */
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
        return 1;
    }

    /* allocate/validate initial 'nptrs' pointers */
    if (!(lines = calloc (nptrs, sizeof *lines))) {
        perror ("calloc-lines");
        return 1;
    }

    /* read each line with POSIX getline */
    while ((nchr = getline (&line, &n, fp)) != -1) {
        if (nchr && line[nchr - 1] == '\n') /* check trailing '\n' */
            line[--nchr] = 0;               /* overwrite with nul-char */
        char *buf = strdup (line);          /* allocate/copy line */
        if (!buf) {     /* strdup allocates, so validate */
            fprintf (stderr, "error: strdup allocation failed.\n");
            break;
        }
        lines[ndx++] = buf;     /* assign start address for buf to lines */
        if (ndx == nptrs) {     /* if pointer limit reached, realloc */
            /* always realloc to temporary pointer, to validate success */
            void *tmp = realloc (lines, sizeof *lines * nptrs * 2);
            if (!tmp) {         /* if realloc fails, bail with lines intact */
                perror ("realloc-lines");
                break;          /* don't exit, lines holds current lines */
            }
            lines = tmp;        /* assign reallocted block to lines */
            /* zero all new memory (optional) */
            memset (lines + nptrs, 0, nptrs * sizeof *lines);
            nptrs *= 2;         /* increment number of allocated pointers */
        }
    }
    free (line);                    /* free memory allocated by getline */

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

    for (size_t i = 0; i < ndx; i++) {
        printf ("line[%3zu] : %s\n", i, lines[i]);
        free (lines[i]);            /* free memory for each line */
    }
    free (lines);                   /* free pointers */

    return 0;
}

输入文件示例

$ cat dat/3lines.txt
This is the first line of a text.
Second line comes next.
File ends here.

使用/输出示例

$ ./bin/getline_readfile <dat/3lines.txt
line[  0] : This is the first line of a text.
line[  1] : Second line comes next.
line[  2] : File ends here.

内存使用/错误检查

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

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

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

$ valgrind ./bin/getline_readfile <dat/3lines.txt
==12179== Memcheck, a memory error detector
==12179== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==12179== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==12179== Command: ./bin/getline_readfile
==12179==
line[  0] : This is the first line of a text.
line[  1] : Second line comes next.
line[  2] : File ends here.
==12179==
==12179== HEAP SUMMARY:
==12179==     in use at exit: 0 bytes in 0 blocks
==12179==   total heap usage: 5 allocs, 5 frees, 258 bytes allocated
==12179==
==12179== All heap blocks were freed -- no leaks are possible
==12179==
==12179== For counts of detected and suppressed errors, rerun with: -v
==12179== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

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

Answer 3

考虑到担心1000字节（即1KB）的存在，这有点有趣，系统RAM可能在GB的范围内，并且由于磁盘和文件缓存，所有内容都可能会加载到RAM中。 但是这是一种遍历文件并查找将被视为一行的最大字符数的方法

    int Max_Line_Length_in_File ( FILE *fp )
    {
       char ch;
       int count = 0;
       int maxcount = -1;

       /* assumes fp is already opened and at beginning of text file */

       ch = fgets( fp );
       while ( ! feof( fp ) )
       {
          if (( ch == '\n' ) || ( ch == '\0' ))
             count = 0;
          else
             count++;

          if ( count > maxcount )
             maxcount = count;
       }
       /* don't forget to do a rewind on the fileptr if needed */
    }

一旦知道一行的最大长度，就可以做一个'malloc（）'来知道所需的最小值...或者可以为每一行做一次，并且可以轻松地修改上面的内容并添加一个计数器查找的行数。 因此，如果内存是一个问题，这是一种使用较少变量的方法，一个int通常为4个字节，因此小于16个字节即可得到number_of_lines和max_line_length个答案

Answer 4

#include <stdio.h>  //Used for fopen, fseek, ftell, fread, fclose
#include <stdlib.h> //Used for malloc and free
#include <assert.h> //Used for assert

int main(void)
{
    FILE* file = fopen("your_file_here.txt", "r"); //Open a file
    fseek(file, 0, SEEK_END);                      //Find the end of the file
    long filesize = ftell(file);                   //Save the position (length)
    fseek(file, 0, SEEK_SET);                      //Return to the beginning of the file
    char* buffer = malloc(filesize + 1);           //Allocate enough memory
    assert(buffer);                                //Ensure that the memory was allocated
    fread(content, 1, filesize, file);             //Fill the allocated memory with the file content

    //Do whatever you like 
    //{...}

    free(buffer); //Free up memory
    fclose(file); //Close file
}

Answer 5

在支持该文件的系统（例如，所有现代台式机操作系统）上，一个简单的解决方案是对整个文件进行内存映射。 然后，文件内容可直接寻址到内存，并且操作系统虚拟内存管理将为您处理内存和页面调度，而与文件大小无关。

然后，您可以像对待内存一样直接对文件内容进行操作-无需显式分配，重新分配或（甚至应该修改回写），也可以-或通过扫描换行来获取每行的开始和长度，分配确切的内存量并复制它。

用于内存映射文件的Windows和POSIX API有所不同，但是您会发现大量示例，说明了所使用的任何系统。