FILE as parameter to function

[divideby0]

void foo(FILE *f1, FILE **f2)
{
    fputs("...",  f1);
    fputs("...", *f2);
}
 
int main(void)
{
    FILE *fp1 = fopen(...),
         *fp2 = fopen(...);
 
    if(fp1 && fp2)
    {
        foo(fp1, &fp2);
        ...
    }
    ...
}

Forever, I've passed FILE objects into functions like the first parameter; I've never had an issue reading or writing files using that form - no file errors, no compiler warnings, etc. Recently, I saw the second paramter form, and wondered why that was?

I still don't quite get this part of pointers. What's the second parameter form doing differently than the first when the first version *appears* to work as intended?? I'm quite confused now.

TIA

[weaknessforcats]

The first argument, FILE* is the address of a FILE struct. The function cannot change the address in the pointer. It has to use the FILE provided by address.

The second argument is the address of a FILE*. This allows the function to change which FILE* it is using by changing the address in the FILE*.

You use pointers to make run time decisions and to pass info to,and retreive answers from functions. You can't just pass in your variable since a copy is made and the copy can only update the copy. The copy is deleted when the function completes taking the change with it. So instead you pass in the address of the variable and the function makes the change at that address. The variable at that address lives on after the function completes thereby preserving the change.

[divideby0]

First and foremost, thank you wfc.

The second argument is the address of a FILE*. This allows the function to change which FILE* it is using by changing the address in the FILE*.

I follow that the pointer to the FILE struct cannot be changed, but I don't quite follow what the FILE* can do in practice.

If a declaration was

void some_function(FILE **ptr)
{
   *ptr = fopen("..."); ?? 
}
 
// in main
FILE *fp = NULL;
 // would a file be opened here??
 
some_function(&fp);
// would it be opened in the function??
// is it to point to an exiting * to FILE struct??
 

I don't understand how this mechanism works at all. I've only ever known opening a FILE* in main and passing this to whatever functions I needed, and then closing it in main.

Could you post a brief example of how this would work? A visual may help me better understand it.

[weaknessforcats]

OK. Suppose you are writing a log file system where when the log reaches a set limit, you close the current log, then create a new one. the new log has its own FILE so you get the address of this new FILE into the FILE* used by the rest of the logging system. To do that you need the address of the FILE* used by everyone else. That would be a FILE**. Your function would need that FILE** should it become necessary to start a new log file.

void CreateNewLog(FILE** currentlog)
{
    /* close current log file */
    fclose(*currentlog);        
 
    /* create new log*/
    FILE* fp = open(etc...);
 
    *currentlog = fp;
}

[divideby0]

You are always so helpful even if I don't quite get it the first, fifth or hundredth time. :)

It sounds like this would be for something like a server or high volume application. If so, that would certainly explain why I've never seen it before.

If I understand you correctly, would this code be right? "status" returned 0 for each iteration and each file was created with all but the last having data written to it.

I'm guessing the last file was created within the function, but returned to the caller without writing any data since it hadn't been assigned to *currentlog before the write operation?

#include <stdio.h>
 
int CreateNewLog(FILE** currentlog, const char *fname, const char *fmode)
{
    FILE* fp = fopen(fname, fmode);
 
    if(fp && *currentlog)
    {
        fprintf(*currentlog, "%s %s", fname, fmode);
        fclose(*currentlog);
        *currentlog = fp;
        return 0;
    }    
    else
    {
        *currentlog = NULL;
        return -1;
    }
}
 
int main(void)
{
    char flist[BUFSIZ];
    int i;
    FILE *fh = fopen("file00", "w+");
 
    for(i=1; i <= 10; ++i)
    {
        sprintf(flist, "file%02d", i);
        printf("status: %d\n", CreateNewLog(&fh, flist, "w+"));
    }
 
    if(fh)
        fclose(fh);
 
    getchar();
    return 0;
}

[weaknessforcats]

It looks like you have the idea. I would use an fprintf to log the create.

[divideby0]

Thank you; I appreciate your explanation and time.