Print in terminal after`freopen("file.txt", "wb", stdout);` (or similar solution to preserve a printing function)

I want to store the printed output of a function with freopen("file.txt", "wb", stdout); (or another solution, but the function matrix_output_printf() should remained untouched.
However, I want to be able to further print something after having closed fclose(stdout); as shown below but the hello of printf("hello"); does not appear in terminal. Is it possible print hello in another way (on a MacOS system).

/* 
 *  main.c 
 *  https://stackoverflow.com/questions/75349098/stream-the-output-of-a-void-function-using-printf/75352112#75352112
 */
#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);
  printf("hello");
  return 0;
}

Edit

The code provided in the answer is not working on my MacOS computer ( 'io.h' file not found). Is there another solution portable for UNIX like systems?

Tried and tested on my Windows box:

#include <stdio.h>
#include <stdlib.h>
#include <io.h>

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( void ) {
	int saved = _dup( fileno( stdout ) );

	freopen( "file.txt", "w", stdout );
	matrix_output_printf();
	fclose( stdout );

	_dup2( saved, 1 );

	printf( "hello\n" );

	return 0;
}

If stdout was originally tied to the console, you can reopen the stream to /dev/tty:

#include <stdio.h>

void matrix_output_printf(void) {
    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", "w", stdout);
    matrix_output_printf();
    freopen("/dev/tty", "w", stdout);
    printf("hello");
    return 0;
}

This should work on most unix systems, such as macOS, but if stdout was redirected to another file or device, reopening it with freopen won't work. You could try and duplicate the system handle with dup() and use fdopen() to open a standard stream after closing stdout, but there is no guarantee that the stream returned by fdopen will be the same as stdout.

Using freopen for your purpose is a hack. A much better approach is to rewrite matrix_output_printf to take a FILE * argument for the output stream, or a const char *filename for the name of the file to produce:

void matrix_output_printf(const char *filename) {
    FILE *fp = stdout;
    if (filename) {
        fp = fopen(filename, "w");
        if (fp == NULL) {
            /* handle error */
            return;
        }
    }
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            fprintf(fp, "%d\t", i + j);
        }
        fprintf(fp, "\n");
    }
    if (filename)
        fclose(fp);
}

Another option:

1. Flush the stream
2. Duplicate stdout's file descriptor before calling the function, duplicate a file descriptor open to the desired file to the stream's original file descriptor value
3. Call the function
4. Restore the original stdout descriptor

Similar to this:

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>

void matrix_output_printf(void){
  for (int i = 0; i < 3; i++){
    for (int j = 0; j < 3; j++){
      printf("%d\t", i+j);
    }
    printf("\n");
  }
}

int main()
{ 
  int fd = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
  int savedStdoutFD = dup(fileno(stdout));
  fflush(stdout);
  dup2(fd, STDOUT_FILENO);
  close(fd);

  matrix_output_printf();

  fflush(stdout);
  dup2(savedStdoutFD, STDOUT_FILENO);
  close(savedStdoutFD);

  printf("hello\n");
  return 0;
}

Note that this code is inherently unsafe to use in a multithreaded process.

@chqrlie had the best answer: "A much better approach is to rewrite matrix_output_printf to take a FILE * argument for the output stream, or a const char *filename for the name of the file to produce".