Stream the output of a void function using printf() - c

Question

I want to store the output of a function (matrix_output_printf()) printing the following output (a matrix):
0 1 2
1 2 3
2 3 4
I would like to save this output in a text file.
In a first attempt, I modified the original in matrix_output_fprintf() so that it stores the output continuously using fprintf(). I indeed stores the output but the code of matrix_output_printf() has been changed
However, I would like not to modify matrix_output_printf() as, let's say, it is part of a package and want to test it without modifiying it.
Is there a way to store (using C and not bash) the output of matrix_output_printf() from outside the function (or without using fprintf()?
The content of file.txt is the following:
0 1 2
1 2 3
2 3 4
Here is the code:
/* main.c */
#include <stdio.h>
#include <stdlib.h>
void matrix_output();
void matrix_output_printf(){
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
printf("%d\t", i+j);
}
printf("\n");
}
}
void matrix_output_fprintf(){
FILE * fp;
fp = fopen("file.txt", "w");
fclose(fp);
fp = fopen("file.txt", "ab");
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
fprintf(fp, "%d\t", i+j);
}
fprintf(fp, "\n");
}
fclose(fp);
}
int main ()
{
matrix_output_printf();
matrix_output_fprintf();
return 0;
}

Answer 1

If you want to redirect stdout to a file, you can do that with the freopen function:
freopen("file.txt", "wb", stdout);
After this call, any write to stdout will write to the file "file.txt".

Answer 2

For the sake of completeness, here is the complete working code which worked for me, thanks to the answer of #dbush:
/* main.c */
#include <stdio.h>
#include <stdlib.h>
void matrix_output();
void matrix_output_printf(){
for (int i = 0; i < 3; i++){
for (int j = 0; j < 3; j++){
printf("%d\t", i+j);
}
printf("\n");
}
}
int main ()
{
freopen("file.txt", "wb", stdout);
matrix_output_printf();
fclose(stdout);
return 0;
}

Answer 3

If you're on a POSIX-compliant system, you can use the dup2 system call.
From the man page:
The dup() system call allocates a new file descriptor that refers
to the same open file description as the descriptor oldfd.
.....The dup2() system call performs the same task as dup(), but
instead of using the lowest-numbered unused file descriptor, it
uses the file descriptor number specified in newfd. In other
words, the file descriptor newfd is adjusted so that it now
refers to the same open file description as oldfd.
Here's an example:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#define FILE_NAME "file.txt"
int main (void)
{
int fd = open (FILE_NAME, O_WRONLY | O_CREAT);
if (fd == -1) {
perror ("open()");
return EXIT_FAILURE;
}
/* We want stdout to point to this file */
int rv = 0;
do {
rv = dup2 (fd, STDOUT_FILENO);
} while ((rv == -1) && (errno == EINTR));
if (rv == -1) {
close (fd);
perror ("dup2()");
return EXIT_FAILURE;
}
/* We no longer need the original file descriptor */
close (fd);
/* Now writing to STDOUT_FILENO == FILE.TXT_FILENO */
printf ("You're my sunshine now.\n");
return EXIT_FAILURE;
}
Something to note:
If the file descriptor newfd was previously open, it is closed
before being reused; the close is performed silently (i.e., any
errors during the close are not reported by dup2()).
So we don't need to close STDOUT_FILENO after the call to dup2(). It is done for us automatically.
But the above function is only defined in the POSIX standard, not the C standard. So we can take another route (one already mentioned). You can redirect the stdout to file.txt with freopen.
From the man page:
The freopen() function shall first attempt to flush the stream
associated with stream as if by a call to fflush(stream).
Failure to flush the stream successfully shall be ignored. If
pathname is not a null pointer, freopen() shall close any file
descriptor associated with stream. Failure to close the file
descriptor successfully shall be ignored. The error and end-of-
file indicators for the stream shall be cleared.
The freopen() function shall open the file whose pathname is the
string pointed to by pathname and associate the stream pointed to
by stream with it. The mode argument shall be used just as in
fopen().
The original stream shall be closed regardless of whether the
subsequent open succeeds.
#define FILE_NAME "file.txt"
/* Upon successful completion, freopen() shall return the
* value of stream. Otherwise, a null pointer shall be returned,
* and errno shall be set to indicate the error.
*/
FILE *fp = freopen (FILE_NAME, "w", stdout);
if (!fp) {
/* freopen() failed. Handle error here. */
....
}
Note that this has the disadvantage that there's generally no way to undo it, and as #chqrlie said in the comments: "Passing a FILE * to the function for it to use fprintf() is a much more versatile approach."