c - C 编程：如何将整个文件内容读入缓冲区

Question

我想将文件的全部内容写入缓冲区。该文件实际上只包含一个字符串，我需要将其与字符串进行比较。

什么是最有效的选择，即使在 linux 上也是可移植的。

环境：窗户

Answer 1

Linux 和 Windows 之间的可移植性是一个令人头疼的问题，因为 Linux 是一个符合 POSIX 的系统，通常具有适用于 C 的适当、高质量的工具链，而 Windows 甚至没有在 C 标准库中提供很多功能。

但是，如果你想坚持标准，你可以这样写：

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

FILE *f = fopen("textfile.txt", "rb");
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
fseek(f, 0, SEEK_SET);  /* same as rewind(f); */

char *string = malloc(fsize + 1);
fread(string, fsize, 1, f);
fclose(f);

string[fsize] = 0;

这里string将包含文本文件的内容作为正确的以 0 结尾的 C 字符串。此代码只是标准 C，它不是 POSIX 特定的（尽管它不能保证它可以在 Windows 上工作/编译......）

Answer 2

这是我推荐的。

它应该符合 C89，并且是完全可移植的。特别是，它也适用于 POSIXy 系统上的管道和套接字。

这个想法是我们以大块（READALL_CHUNK）读取输入，根据需要动态重新分配缓冲区。我们只使用realloc(), fread(),ferror()和free():

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

/* Size of each input chunk to be
   read and allocate for. */
#ifndef  READALL_CHUNK
#define  READALL_CHUNK  262144
#endif

#define  READALL_OK          0  /* Success */
#define  READALL_INVALID    -1  /* Invalid parameters */
#define  READALL_ERROR      -2  /* Stream error */
#define  READALL_TOOMUCH    -3  /* Too much input */
#define  READALL_NOMEM      -4  /* Out of memory */

/* This function returns one of the READALL_ constants above.
   If the return value is zero == READALL_OK, then:
     (*dataptr) points to a dynamically allocated buffer, with
     (*sizeptr) chars read from the file.
     The buffer is allocated for one extra char, which is NUL,
     and automatically appended after the data.
   Initial values of (*dataptr) and (*sizeptr) are ignored.
*/
int readall(FILE *in, char **dataptr, size_t *sizeptr)
{
    char  *data = NULL, *temp;
    size_t size = 0;
    size_t used = 0;
    size_t n;

    /* None of the parameters can be NULL. */
    if (in == NULL || dataptr == NULL || sizeptr == NULL)
        return READALL_INVALID;

    /* A read error already occurred? */
    if (ferror(in))
        return READALL_ERROR;

    while (1) {

        if (used + READALL_CHUNK + 1 > size) {
            size = used + READALL_CHUNK + 1;

            /* Overflow check. Some ANSI C compilers
               may optimize this away, though. */
            if (size <= used) {
                free(data);
                return READALL_TOOMUCH;
            }

            temp = realloc(data, size);
            if (temp == NULL) {
                free(data);
                return READALL_NOMEM;
            }
            data = temp;
        }

        n = fread(data + used, 1, READALL_CHUNK, in);
        if (n == 0)
            break;

        used += n;
    }

    if (ferror(in)) {
        free(data);
        return READALL_ERROR;
    }

    temp = realloc(data, used + 1);
    if (temp == NULL) {
        free(data);
        return READALL_NOMEM;
    }
    data = temp;
    data[used] = '\0';

    *dataptr = data;
    *sizeptr = used;

    return READALL_OK;
}

上面，我使用了一个恒定的块大小，READALL_CHUNK== 262144 ( 256*1024)。这意味着在最坏的情况下，最多有 262145 个字符被浪费（已分配但未使用），但只是暂时的。最后，该函数将缓冲区重新分配到最佳大小。此外，这意味着我们每读取一兆字节的数据进行四次重新分配。

上面代码中默认的 262144 字节是一个保守值；它甚至适用于旧的小型笔记本电脑和 Raspberry Pi 以及大多数具有至少几兆字节 RAM 可用于该过程的嵌入式设备。然而，它并没有小到会减慢大多数系统上的操作（由于许多读取调用和许多缓冲区重新分配）。

对于此时（2017 年）的台式机，我建议使用更大的READALL_CHUNK，也许是#define READALL_CHUNK 2097152（2 MiB）。

因为 的定义READALL_CHUNK是受保护的（即，仅当它在代码中仍未定义的那一点时才定义），您可以在编译时使用（在大多数 C 编译器中）-DREADALL_CHUNK=2097152命令行选项覆盖默认值 --但请检查您的编译器选项以使用命令行选项定义预处理器宏。

Answer 3

便携式解决方案可以使用getc.

#include <stdio.h>

char buffer[MAX_FILE_SIZE];
size_t i;

for (i = 0; i < MAX_FILE_SIZE; ++i)
{
    int c = getc(fp);

    if (c == EOF)
    {
        buffer[i] = 0x00;
        break;
    }

    buffer[i] = c;
}

如果您不想拥有MAX_FILE_SIZE宏或者它是一个大数字（这样buffer会太大而无法放入堆栈），请使用动态分配。