回到C中的main时，为什么传递给函数的FILE指针改变了？

Question

As far as I understand passing a pointer to a function essentially passes the copy of the pointer to the function in C. I have a FILE pointer that I pass to a function func() , func() reads a line from a file and then when we return to main() . I read another line from the file using the same FILE pointer.

However, while I would imagine that I'd read the line exactly from before func() was called, I actually read the next line after what func() had read. Can you please explain why FILE pointer behaves this way?

This is my code:

#include <stdio.h>

#define STR_LEN 22

void func(FILE *fd);

int main() {
    FILE *fd;
    char mainString[STR_LEN];
    if (!(fd = fopen("inpuFile", "r"))) {
        printf("Couldn't open file\n");
        fprintf(stderr, "Couldn't open file\n");
    }

    func(fd);
    fgets(mainString, STR_LEN, fd);
    printf("mainString = %s\n", mainString);

    fclose(fd);

    return 0;
}

void func(FILE *fd) {
    char funcString[STR_LEN];
    fgets(funcString,STR_LEN, fd);
    printf("funcString = %s\n", funcString);
}

Answer 1

However, while I would imagine that I'd read the line exactly from before func was called ...

I can't imagine why you would imagine that. What if the FILE* references a network connection that has no replay capability at all where reading is consumption. Where would the line be stored such that you could read it again? There would be absolutely no place to put it.

Not only would I not imagine that, it's kind of crazy.

As far as I understand passing a pointer to a function essentially passes the copy of the pointer to the function in C.

Correct. But a copy of a pointer points to the very same object. If I point to a car and you copy me, you're pointing to the very same one and only car that I'm pointing to.

Answer 2

Because FILE pointer points on some data that gets changed when the file is read/written.

So the pointer doesn't change (still points to the handler structure of the file) but the data pointed by the structure does.

Try passing pointer as const FILE * you'll see that you cannot because fread operation (and others) alter the pointed data.

One way would be to duplicate the file descriptor, which dup does, but doesn't work on buffered FILE object, only raw file descriptors.

Answer 3

The problem is in your initial statement: As far as I understand passing a pointer to a function essentially passes the copy of the pointer to the function in C .

This does not change much, as whatever you are accessing as a pointer, still holds the location of the FILE you are accessing, the whole point of using pointers as arguments for a function in C, is so that you can modify a certain value outside the scope of a function.

For example, common usage of an integer pointer as a function argument:

void DoSomethingCool(int *error);

Now using this code to catch the error would work like this:

int error = 0;
DoSomethingCool(&error);

if(error != 0)
  printf("Something really bad happened!");

In other words, the pointer will actually modify the integer error, by accessing it's location and writing to it.

An important thing to keep in mind to avoid these kinds of misunderstandings is to recognize that all a pointer is, is essentially the address of something.

So you could (in theory, by simplifying everything a lot) think of an int * as simply an int , the value of which happens to be an address of some variable, for a FILE * , you can think of it as an int , where the value of the int is the location of the FILE variable.

Answer 4

FILE *fd is a pointer only in the sense that its implementation uses C construct called a "pointer". It is not a pointer in the sense of representing a file position.

FILE *fd represents a handle to a file object inside the I/O library, a struct that includes the actual position of the file. In a grossly simplified way, you can think of fd as a C pointer to a file pointer.

When you pass fd around your program, I/O routines make modifications to the file position. This position is shared among all users of fd . If a func() makes a change to that position by reading some data or by calling fseek , all users of the same fd will see the updated position.