Preserving file pointer between function calls - c

Question

I have a code where I'm accessing a binary file several times. Each time I call the function, it opens the file for reading and it reads out only the required number of bytes (say n bytes each time).
The binary file contains time series data, and what I'd like it to be able to do is run the function call through a loop, and every time I call the function to open the same file, it needs to read out the next chunk of data, i.e, I don't want the file pointer to be reset every time. Is there a way to do this?
The function looks like so:
int readBinary(float *binImage, int gelements) {
imageFile = fopen("tmpImageFile", "r");
if (imageFile == NULL) {
fprintf(stderr, "Error opening file\n");
return (1);
}
fread(binImage, sizeof(float), gelements, imageFile);
return 0;
}
And in my main code, I'd like to run it through a loop, giving it the array binImage of size gelements every time. I'd rather not give it an array of size gelements * nLoop if that's avoidable.

Answer 1

The quick rules of thumb are
"Life gets easier if you properly separate responsibilities between functions"
and
"Life gets complicated if you use static or global variables".
In this case, giving the readBinary function both the responsibility of managing the FILE and reading the data is too much.
Note that the function doesn't close the handle.
If the handle is a local static in the function then it will be impossible to close it.
It also means that the function will be forever locked into using only "tmpImageFile" (which is not immediately apparent from the function's signature or missing documentation)
If the handle is a global then it may be possible to close it prematurely.
Notice that if you remove the "open file" responsibility the readBinary function is just a call to fread.
The best way to handle this is to skip the readBinary function altogether.
You say you have a caller which reads data in a loop.
Make this caller responsible for opening the FILE, use fread directly in the loop and close the file when you are done.
Now, this might give the caller too much responsibility. Simply have the caller accept the FILE* as a parameter and give the file management responsibility to its caller.
Or the caller's caller's caller, depending on where it makes sense to manage the file's lifetime.

Answer 2

Use a static variable so you retain the file pointer:
int readBinary(float *binImage, int gelements) {
static FILE *imageFile = NULL;
if (imageFile == NULL) {
imageFile = fopen("tmpImageFile", "r");
if (imageFile == NULL) {
perror("Error opening file: ");
return (1);
}
}
fread(binImage, sizeof(float), gelements, imageFile);
return 0;
}

Answer 3

I would pass the FILE* as parameter to function:
int readBinary(float *binImage, int gelements, FILE *imageFile) {
int bytes = fread(binImage, sizeof(float), gelements, imageFile);
return bytes != -1 ? 0 : 1;
}
I also added simple check for fread return value and converting it to your return value convention. Though this function seems so simple, you could just call fread directly, unless you want to add stuff like error print to it.

Answer 4

You can make the file pointer static and initialize it to NULL. Then next time onwards if it is not NULL, then it contains the opened file. Also while closing the file, make sure you make it to NULL again. Same can be done with a global pointer also
int readBinary(float *binImage, int gelements) {
static imageFile = NULL;
if(imageFile == NULL ) imageFile = fopen("tmpImageFile", "r");
if (imageFile == NULL) {
fprintf(stderr, "Error opening file\n");
return (1);
}
fread(binImage, sizeof(float), gelements, imageFile);
return 0;
}