Flushing the output buffers:

printf("Buffered, will be flushed");
fflush(stdout); // Prints to screen or whatever your standard out is

or

fprintf(fd, "Buffered, will be flushed");
fflush(fd);  //Prints to a file

Can be a very helpful technique. Why would you want to flush an output buffer? Usually when I do it, it's because the code is crashing and I'm trying to debug something. The standard buffer will not print everytime you call printf() it waits until it's full then dumps a bunch at once. So if you're trying to check if you're making it to a function call before a crash, it's helpful to printf something like "got here!", and sometimes the buffer hasn't been flushed before the crash happens and you can't tell how far you've really gotten.

Another time that it's helpful, is in multi-process or multi-thread code. Again, the buffer doesn't always flush on a call to a printf(), so if you want to know the true order of execution of multiple processes you should fflush the buffer after every print.

I make a habit to do it, it saves me a lot of headache in debugging. The only downside I can think of to doing so is that printf() is an expensive operation (which is why it doesn't by default flush the buffer).

As far as flushing the input buffer (stdin), you should not do that. Flushing stdin is undefined behavior according to the C11 standard §7.21.5.2 part 2:

If stream points to an output stream ... the fflush function causes any unwritten data for that stream ... to be written to the file; otherwise, the behavior is undefined.

On some systems, Linux being one as you can see in the man page for fflush(), there's a defined behavior but it's system dependent so your code will not be portable.

Now if you're worried about garbage "stuck" in the input buffer you can use fpurge() on that. See here for more on fflush() and fpurge()

I think that flushing the buffer doesn't imply it will be printed to the screen or whatever stdout is redirected to.

Flushing stdout by reading from stdin:

You can achieve the behavior the following buf.c:

#include <stdio.h>
#include <unistd.h>

int main(void)
{
  printf("Hello");
  sleep(2);
  fprintf(stderr, "No output from stdout after 2 seconds\n");

  char buf[10];
  while (fread(buf, sizeof(char), 10, stdin) == 10) {
  }

  sleep(5);
}

Run it:

$ ./buf
No output from stdout after 2 seconds
Hello

"Hello" string is printed to stdout and does not end with a newline) (\n) so it's not flushed after 2 seconds but it's flushed when fread() is run. If it was removed it would be flushed only after last sleep.

Whenever an input operation on any stream actually reads data from its file.

Flushing to file by reading from file:

To reproduce Whenever an input operation on any stream actually reads data from its file. which I think was your main goal:

#include <stdio.h>
#include <unistd.h>

int main(void)
{
  FILE *fp = fopen("FILE", "a+");
  fprintf(fp, "add more characters to FILE\n");
  fprintf(stderr, "wrote more characters to FILE\n");
  sleep(5);

  fprintf(stderr, "reading will now start\n");
  fseek(fp, 0, SEEK_SET);
  char buf[10];
  while (fread(buf, sizeof(char), 10, fp) == 10) {

  }

  fprintf(stderr, "Sleep for 5 seconds before sleep()\n");
  sleep(5);
  fprintf(stderr, "Exit\n");
}

Run it like that, I will a small FILE that only contain a current date and will run a binary in the background so that I would be able to see all messages it prints and be able to examine contents of FILE at the same time:

$ date > FILE
$ ./buf &
[1] 14522
wrote more characters to FILE
$ cat FILE
Sat Nov  9 13:02:28 CET 2024
$ reading will now start
Sleep for 5 seconds before sleep()

$ cat FILE
Sat Nov  9 13:02:28 CET 2024
add more characters to FILE
Exit

As you see add more characters to FILE line has been added to FILE only after fread() was run.