如何从文件的一行中读取多个浮点数

Question

I have the following code which reads from a given input file into and then into struct I have made.

    OFFFile ReadOFFFile(OFFFile fileData, FILE* srcFile)
{
    int nvert, nfaces;
    fscanf(srcFile, "%s\n");
    fscanf(srcFile, "%d %d %s\n", &nvert, &nfaces);
    fileData.nvert = nvert;
    fileData.nfaces = nfaces;
    
    fileData.vertices = (int *) malloc(fileData.nvert * sizeof(float));
    fileData.triFaces = (int *) malloc(fileData.nfaces * sizeof(int));

    // Print to check correct size was allocated
    printf("%d\n", (fileData.nvert * sizeof(float)));
    printf("%d\n", (fileData.nfaces * sizeof(int)));

    int i;
    float ftemp1, ftemp2, ftemp3;
    int itemp1, itemp2, itemp3;

    fscanf(srcFile, "%f", &ftemp1);
    printf("%lf", ftemp1);
    fscanf(srcFile, "%f", &ftemp2);
//    fscanf(srcFile, " %lf", &ftemp3);

/*    for (i = 0; i < nvert; ++i)
    {
        fscanf(srcFile, "%f %f %f\n", &ftemp1, &ftemp2, &ftemp3);
        fileData.vertices[i].x = ftemp1;
        fileData.vertices[i].y = ftemp2;
        fileData.vertices[i].z = ftemp3;
    }
*/
    return(fileData);
}

The problem I am having is with the whole last section that is currently in quotes (The 2 fscanf lines above it are me attempting to test). If I have just one float being read it works fine, but when I add the second or third the whole function fails to even run, although it still compiles. I believe it to be caused by the negative sign in the input, but I don't know how I can fix it.

The data is in the form

OFF
4000 7000 0
0.8267261981964111 -1.8508968353271484 0.6781123280525208
0.7865174412727356 -1.8490413427352905 0.7289819121360779

With the floats continuing on for 4000 lines (hence for loop). These are the structs I have made

typedef struct
{
    float x;
    float y;
    float z;
} Point3D;

typedef struct
{
    int face1;
    int face2;
    int face3;
} triFace;

typedef struct
{
    int nvert;
    int nfaces;
    Point3D *vertices;
    triFace *triFaces;
} OFFFile;

Text dump of another file with a lot less lines, also does not work in the for loop. Only using this for testing. https://justpaste.it/9ohcc

Answer 1

The line:

fscanf(srcFile, "%s\n");

is invoking undefined behavior. The compiler should warn you about that. Once you've invoked UB, there's no point in speculating further about what is happening.

It's not clear to me what you intended that line to do, but if you use %s in a scanf, you need to give it a valid place to write data. You should always check the value returned by scanf to ensure that you have actually read some data, and you should never use "%s" without a width modifier. Perhaps you want something like:

char buf[256];
if( fscanf(srcFile, "%255s ", buf) == 1 ){
        /* Do something with the string in buf */
}

From your comment, it seems that you are intending to use that scanf to skip a line. I strongly recommend using a while(fgetc) loop instead of scanf to do that. If you do want to use scanf, you could try something like fscanf(srcFile, "%*s\n") , but beware that it will stop at the first whitespace, and not necessarily consume an entire line. You could also do fscanf(srcFile, "%*[^\n]%*c"); to consume the line, but you are really better off using a fgetc in a while loop.

Answer 2

Addressing title question:

"How do I read multiple floats from one line of a file"

...with suggestions for a non-scanf() approach.

Assuming the file is opened, (and a file pointer) fp is obtained ), the first two lines are already handled, and values into ints, say the lines value is converted to int lines;

And given your struct definition (modified to use double to accommodate type compatibility in code below):

typedef struct
{
    double x;
    double y;
    double z;
} Point3D; 

In a function somewhere here is one way to parse the contents of each data line into the 3 respective struct values using fgets() , strtok() and strtod() :

char delim[] = " \n";
char *tok = NULL;
char newLine[100] = {0};
Point3D *point = calloc(lines, sizeof(*point));
if(point)
{
    int i = 0;
    while(fgets(newLine, sizeof newLine, fp))
    {
        tok = strtok(newLine, delim);
        if(tok)
        {
            if(parseDbl(tok, &point[i].x))
            {
                tok = strtok(NULL, delim);
                if(tok)
                {
                    if(parseDbl(tok, &point[i].y))
                    {
                        tok = strtok(NULL, delim);
                        if(tok)
                        {
                            if(!parseDbl(tok, &point[i].z))
                            {
                                ;//handle error
                            }else ;//continue
                        }else ;//handle error
                    }else ;//handle error
                }else ;//handle error
            }else ;//handle error
        }else ;//handle error 
        i++;//increment for next read
    }//end of while
}else ;//handle error  

Where parseDbl is defined as:

bool parseDbl(const char *str, double *val)
{
    char *temp = NULL;
    bool rc = true;
    errno = 0;
    *val = strtod(str, &temp);

    if (temp == str)
        rc = false;

    return rc;
}       

Answer 3

Your main problem is the first line in the readOFFFile function:

fscanf(srcFile, "%s\n");

This tries to read a string (presumably the string OFF on the first line of the file), but you don't give fscanf any place to store the string, so it crashes. (As an aside, your compiler really should have warned you about this problem. If it didn't, it's old-fashioned, and there are lots of easy mistakes that it's probably not going to warn you about, and learning C is going to be much harder than it ought to be. Or perhaps you just need to find an option flag or checkbox to enable more warnings.)

You can tell fscanf to read and discard something, without storing it anywhere, using the * modifier. Here's a modified version of your program, that works for me.

void ReadOFFFile(OFFFile *fileData, FILE* srcFile)
{
    fscanf(srcFile, "%*s");
    if(fscanf(srcFile, "%d %d %*s", &fileData->nvert, &fileData->nfaces) != 2) {
        exit(1);
    }
    
    fileData->vertices = malloc(fileData->nvert * sizeof(Point3D));
    fileData->triFaces = malloc(fileData->nfaces * sizeof(triFace));

    int i;

    for (i = 0; i < fileData->nvert; ++i)
    {
        if(fscanf(srcFile, "%f %f %f", &fileData->vertices[i].x,
                                       &fileData->vertices[i].y,
                                       &fileData->vertices[i].z) != 3) {
            exit(1);
        }
    }
}

I have made a few other changes. The other fscanf call, that reads three values but only stores two, also needs a * modifier. I check the return value of fscanf to catch errors (via a crude exit) if the input is not as expected. I got rid of the \n characters in the fscanf calls, since they're not necessary, and potentially misleading. I got rid of some unnecessary temporary variables, and I had the readOFFFile function accept a pointer to an OFFFile structure to fill in, rather than passing and returning it.

Here is the main program I tested it with:

int main()
{
    OFFFile fd;
    FILE *fp = fopen("dat", "r");
    ReadOFFFile(&fd, fp);
    for (int i = 0; i < fd.nvert; ++i)
        printf("%f %f %f\n", fd.vertices[i].x, fd.vertices[i].y, fd.vertices[i].z);
}

This is still an incomplete program: there are several more places where you need to check for errors (opening the file, calling malloc , etc.), and when you do detect an error, you need to at least print a useful error message before exiting or whatever.

One more thing. As I mentioned, those \n characters you had in the fscanf format strings were unnecessary and misleading. To illustrate what I mean, once you get the program working, have it try to read a data file like this:

OFF 2 0
0 0.8267261981964111
-1.8508968353271484 0.6781123280525208
0.7865174412727356 -1.8490413427352905 0.7289819121360779

Totally malformed, but the program reads it without complaint, This is one reason (one of several dozen reasons, actually) why the scanf family of functions is basically useless for most things. These functions claim to "scan formatted data", but their definition of "formatted" is quite loose, in that they actually read free-form input, generally without any regard for line boundaries.

For some advice on graduating beyond scanf and using better, more reliable methods for reading input, see this question . See also this section and this section in some online C programming course notes.