Question

我试图从C中的文件中读取双打，但结果却是一场噩梦。当我想阅读整数或字符时，我似乎无法遇到任何问题，但是双打似乎很难处理。

所以，让我们说我有一个包含两列和四行双数的文件，我想要两个向量来保存每列中的所有数据。我的代码是：

int main(void){

    double v1[4],v2[4];
    FILE *f;
    int i;

    f=fopen("hola.rtf","r");
    if(f==NULL){
            printf("Error fitxer!\n");
            exit(1);
    }
    for(i=0;i<4;i++){
            fscanf(f,"%le",&v1[i]);
            fscanf(f,"%le",&v2[i]);
            printf("%le %le\n",v1[i],v2[i]);
    }
    fclose(f);
    return 0;

但所有打印的值都是0 ......任何想法/提示？

谢谢：）

Answer 1

您不会检查fscanf()的返回值，因此您不知道它是否转换（和读取）数据。

此外，printf() double的说明符为%e（或%f或%g，具体取决于您想要的格式）; %le不是C中的有效说明符，因此如果您的程序打印任何内容，那是因为您的编译器或C库接受%le。（无论它理解的是什么格式，都可能不是double。）

以下是阅读双打的方法：

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

#define  COUNT  4

int main(void)
{
    const char *filename = "hola.rtf";
    FILE *input;
    double v1[COUNT], v2[COUNT];
    int i;

    input = fopen(filename, "r");
    if (!input) {
        fprintf(stderr, "Cannot open %s: %s.\n", filename, strerror(errno));
        return EXIT_FAILURE;
    }

    for (i = 0; i < COUNT; i++) {
        if (fscanf(input, " %le %le", &(v1[i]), &(v2[i])) != 2) {
            fprintf(stderr, "Invalid data in %s.\n", filename);
            fclose(input);
            return EXIT_FAILURE;
        }

        printf("Read %e and %e from %s.\n", v1[i], v2[i], filename);
    }

    if (ferror(input)) {
        fclose(input);
        fprintf(stderr, "Error reading %s.\n", filename);
        return EXIT_FAILURE;
    }
    if (fclose(input)) {
        fprintf(stderr, "Error closing %s.\n", filename);
        return EXIT_FAILURE;
    }

    printf("All %d pairs of doubles read successfully.\n");

    return EXIT_SUCCESS;
}

许多程序员认为他们可以在以后添加错误检查。这是不切实际的;他们通常最终得到的是没有错误检查或没有错误检查的代码。然而，作为用户，您不想知道程序何时出现故障，并产生垃圾而不是理智的结果？我肯定这样做，所有我认识的人都使用代码来做实际的工作。这是一个很重要的习惯，因为如果你学会不去做，那么学习之后就很难做到。

当然可以讨论错误检查的级别。我相信很多会员都会考虑ferror()检查并检查fclose()的结果为＆＃34;不必要的＆＃34;。确实，他们不会在正常的典型操作中失败。程序员有可能永远不会看到其中任何一个失败。然而，当他们确实失败时 - 比如，有人最终在FUSE文件系统上运行你的代码，该文件系统可以在关闭时报告错误 - 这些检查可能意味着大量垃圾之间的差异以及出现问题的早期警告。

如果您恰好同意我的观点（关于半偏执错误检查是良性的，有时对用户非常有用），请考虑以下代码变体，它从命令行中指定的文件中读取所有双重对到动态分配的数组：

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

typedef struct {
    double x;
    double y;
} vec2d;

/* Read all 2D vectors from stream 'input',
   into a dynamically allocated array.
   (Similar to POSIX.1 getline(), but with double vectors.)
   If *dataptr is not NULL, and *sizeptr > 0,
   it will initially be used (but reallocated if needed).
   Returns the number of vectors read,
   or 0 with errno set if an error occurs.
*/
size_t vec2d_readall(FILE *input, vec2d **dataptr, size_t *sizeptr)
{
    vec2d *data;
    size_t size;
    size_t used = 0;

    if (!input || !dataptr || !sizeptr) {
        /* At least one of the parameters is NULL. */
        errno = EINVAL;
        return 0;
    }

    if (ferror(input)) {
        /* input stream is already in error state. */
        errno = EIO;
        return 0;
    }

    if (!*dataptr || !*sizeptr) {
        /* *dataptr is NULL, or *sizeptr == 0,
           so we initialize them to empty. */
        *dataptr = NULL;
        *sizeptr = 0;
    }
    data = *dataptr;
    size = *sizeptr;

    while (1) {

        if (used >= size) {
            /* We need to grow the data array. */

            /* Simple allocation policy:
               allocate in sets of roughly 1024 vectors. */
            size = (used | 1023) + 1021;
            data = realloc(data, size * sizeof *data);
            if (!data) {
                /* Realloc failed! */
                errno = ENOMEM;
                return 0;
            }

            *dataptr = data;
            *sizeptr = size;
        }

        if (fscanf(input, " %lf %lf", &(data[used].x), &(data[used].y)) != 2)
            break;

        /* One more vector read successfully. */
        used++;
    }

    /* If there was an actual I/O error, or
       the file contains unread data, set errno
       to EIO, otherwise set it to 0. */
    if (ferror(input) || !feof(input))
        errno = EIO;
    else
        errno = 0;

    return used;
}

因为vec2d_readall()函数总是设置errno（如果没有错误发生到0），使用上面的函数从标准输入读取所有双对作为2D向量非常简单：

int main(void)
{
    vec2d     *vectors = NULL;
    size_t num_vectors = 0;
    size_t max_vectors = 0;

    size_t i;

    num_vectors = vec2d_readall(stdin, &vectors, &max_vectors);
    if (errno) {
        fprintf(stderr, "Standard input: %s.\n", strerror(errno));
        return EXIT_FAILURE;
    }

    printf("Read %zu vectors from standard input,\n", num_vectors);
    printf("with memory allocated for up to %zu vectors.\n", max_vectors);

    for (i = 0u; i < num_vectors; i++)
        printf("%f %f\n", vectors[i].x, vectors[i].y);

    return EXIT_SUCCESS;
}

在编写vec2d_readall()时花费了一些额外的精力简化了我们的main()。另外，如果我们发现我们需要类似的函数来读取3D矢量，我们只需要添加typedef struct { double x; double y; double z } vec3d;，并对vec2d_readall()进行一些非常小的更改，将其转换为vec3d_readall()

最重要的是，如果数据存在任何问题，我们可以依赖vec2d_readall() 失败。我们可以添加错误报告，而不仅仅是break;退出循环。

如果你想知道评论中提到的getline()，它是一个POSIX.1-2008标准函数，允许POSIXy系统中的C程序员读取无限长度的输入行。它类似于fgets()，但具有动态内存管理。

读取双打形成C

1 个答案: