c - fscanf 空间不足，如何捕获？

Question

我认为我找到了一个很好的解决方案，可以避免读取对于数组来说太大的值。

我正在使用这段代码(我知道它并不完美；它主要只是说明了我的问题):

char myString[25][10]

while(fscanf(fp, "%24s", myString[i]) != EOF && i < MAX){
    i++;
}

获取输入并将其读入数组。如果该行长度超过 25 个字符，则会将其拆分并将较长的部分放在二维数组(行)的下一部分上。效果很好，直到接近末尾，所以在第 8 行，您得到一行 75 长的行，它希望将其分成数组中的 3 行。但是数组中只剩下另外两行的空间，所以它崩溃了。

我不知道如何以动态的方式走这条线。我不必在 while 循环中执行此操作，但如何获取下一行并测量其长度。如何动态执行这些读取操作和 malloc？

Answer 1

使用fgets()固定大小的动态字符串数组

使用fgets() - strdup()是这里唯一不完全可移植的部分:

char *data[10];
int   i;                             // Needs to last longer than the loop

for (i = 0; i < 10; i++)
{
    char buffer[4096];
    if (fgets(buffer, sizeof(buffer), fp) == 0)
        break;
    buffer[strlen(buffer)-1] = '\0'; // Zap last character; normally newline
    data[i] = strdup(buffer);        // Error check allocation?
}

如果疯子用它来读取单行数据超过 4095 个字符的大型 JSON 文件，这可能会遇到问题。对于大多数用途，您不太可能遇到 4 KiB 的行，但这是您的判断。

使用 getline() 固定大小的动态字符串数组

使用 POSIX 2008 getline() ——不同的可移植性问题:

char *data[10];
int   i;

for (i = 0; i < 10; i++)
{
    char   *buffer = 0;
    size_t  buflen = 0;
    ssize_t actlen;
    if ((actlen = getline(&buffer, &buflen, fp)) < 0)
        break;
    buffer[actlen-1] = '\0';       // Zap last character; normally newline
    data[i] = buffer;
}

这不会对行的长度施加任何上限，并且 getline() 会分配所有空间。

请注意，我没有检查被修改的字符是否是任一片段中的换行符。您可以(可以说应该)添加该检查。您可能有一个末尾没有换行符的文件；从技术上讲，它不是一个文本文件(它们总是以换行符结尾)，但它在 Unix 系统上有效。

固定大小字符串的固定大小数组

保留预先分配的内存:

char data[10][26];
int  i;

for (i = 0; i < 10; i++)
{
    if (fscanf(fp, "%25s", data[i]) != 1)
        break;
    int c;  // Gobble new line
    while ((c = getc(fp)) != EOF && c != '\n')
        ;
}

请注意，这读取的是单词，而不是行。它停在空白处。要读取行，您可以使用扫描集转换规范:

   if (fscanf(fp, "%25[^\n]", data[i] != 1)

然后，您必须决定是否像以前一样吞噬该行的其余部分，或者是否在 "%25[^\n]" 中插入一个微妙但关键的空格来吞噬空白(在开始转换之前耗尽空白)。

动态字符串的动态数组

char   **data   = 0;
size_t   numstr = 0;  /* Number of strings in use */
size_t   maxstr = 0;  /* Number of pointers allocated */

char   *buffer = 0;
size_t  buflen = 0;
ssize_t actlen;

while ((actlen = getline(&buffer, &buflen, fp)) > 0)
{
    if (numstr >= maxstr)
    {
        assert(numstr == maxstr);
        size_t newnum = maxstr * 2 + 2;
        void  *newspc = realloc(data, newnum * sizeof(char *));
        if (newspc == 0)
        {
            /* memory allocation failed - data still valid */
            break;
        }
        maxstr = newnum;
        data = newspc;
    }
    buffer[actlen-1] = '\0';       // Zap last character; normally newline
    data[numstr++] = buffer;
    buffer = 0;                    // Reset so getline() allocates on next read
    buflen = 0;
}

并非所有人都赞成使用 realloc() 来初始分配然后重新分配内存空间；如果您愿意，可以在循环之前执行 malloc() 。 2 * maxstr + 2 确保您在第一次分配时获得非零计数(实际上是 2)，并且足够小以测试重新分配代码(一个好主意)。每次加倍都会摊销分配成本。循环结束后，您可以重新分配数据以将 data 数组缩小到实际大小:

realloc(data, numstr * sizeof(char *));

您应该检查它是否没有失败，但它不应该这样做。这是否真的值得这样做还有待商榷。

<小时/>

警告

上述代码的变体现已使用编译器和测试程序进行了正式测试。SSCCE 如下所示。

请注意，分配的内存并未在上方(或下方)释放。始终确保您知道分配的内存何时将被释放。一般来说，这意味着您需要一个合适的函数来完成这项工作；仅仅让操作系统在程序退出时释放内存通常是 Not Acceptable 。

SSCCE (Short, Self-Contained, Correct Example)

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

static void dump_strings(FILE *fp, const char *tag, size_t num, char **data)
{
    fprintf(fp, "%s:\n", tag);
    for (size_t i = 0; i < num; i++)
        fprintf(fp, " %2zu: [%s]\n", i, data[i]);
}

static void func1(FILE *fp)
{
    char *data[10];
    int   i;                             // Needs to last longer than the loop

    for (i = 0; i < 10; i++)
    {
        char buffer[4096];
        if (fgets(buffer, sizeof(buffer), fp) == 0)
            break;
        buffer[strlen(buffer)-1] = '\0'; // Zap last character; normally newline
        data[i] = strdup(buffer);        // Error check allocation?
    }
    dump_strings(stdout, "func1", i, data);
    /* Leak! */
}

static void func2(FILE *fp)
{
    char *data[10];
    int   i;

    for (i = 0; i < 10; i++)
    {
        char   *buffer = 0;
        size_t  buflen = 0;
        ssize_t actlen;
        if ((actlen = getline(&buffer, &buflen, fp)) < 0)
            break;
        buffer[actlen-1] = '\0';       // Zap last character; normally newline
        data[i] = buffer;
    }
    dump_strings(stdout, "func2", i, data);
    /* Leak! */
}

static void func3(FILE *fp)
{
    char   data[10][26];
    size_t i;

    for (i = 0; i < 10; i++)
    {
        if (fscanf(fp, "%25[^\n]", data[i]) != 1)
            break;
        int c;
        while ((c = getc(fp)) != EOF && c != '\n')
            ;
    }
    printf("%s:\n", "func3");
    for (size_t j = 0; j < i; j++)
        printf("%2zu: [%s]\n", j, data[j]);
}

static void func4(FILE *fp)
{
    char   **data   = 0;
    size_t   numstr = 0;  /* Number of strings in use */
    size_t   maxstr = 0;  /* Number of pointers allocated */

    char    *buffer = 0;
    size_t   buflen = 0;
    ssize_t  actlen;

    while ((actlen = getline(&buffer, &buflen, fp)) > 0)
    {
        if (numstr >= maxstr)
        {
            assert(numstr == maxstr);
            size_t newnum = maxstr * 2 + 2;
            void  *newspc = realloc(data, newnum * sizeof(char *));
            if (newspc == 0)
            {
                /* memory allocation failed - data still valid */
                break;
            }
            maxstr = newnum;
            data = newspc;
        }
        buffer[actlen-1] = '\0';       // Zap last character; normally newline
        data[numstr++] = buffer;
        buffer = 0;                    // Reset so getline() allocates on next read
        buflen = 0;
    }
    dump_strings(stdout, "func4", numstr, data);
    /* Leak! */
}

int main(void)
{
    func1(stdin);
    func2(stdin);
    func3(stdin);
    func4(stdin);
    return(0);
}

除了像筛子一样泄漏之外，valgrind 说这还可以。它主要是在自己的源代码上进行测试的。