The behaviour of printf()
seems to depend on the location of stdout
.
stdout
is sent to the console, then printf()
is line-buffered and is flushed after a newline is printed.stdout
is redirected to a file, the buffer is not flushed unless fflush()
is called.printf()
is used before stdout
is redirected to file, subsequent writes (to the file) are line-buffered and are flushed after newline.When is stdout
line-buffered, and when does fflush()
need to be called?
void RedirectStdout2File(const char* log_path) {
int fd = open(log_path, O_RDWR|O_APPEND|O_CREAT,S_IRWXU|S_IRWXG|S_IRWXO);
dup2(fd,STDOUT_FILENO);
if (fd != STDOUT_FILENO) close(fd);
}
int main_1(int argc, char* argv[]) {
/* Case 1: stdout is line-buffered when run from console */
printf("No redirect; printed immediately\n");
sleep(10);
}
int main_2a(int argc, char* argv[]) {
/* Case 2a: stdout is not line-buffered when redirected to file */
RedirectStdout2File(argv[0]);
printf("Will not go to file!\n");
RedirectStdout2File("/dev/null");
}
int main_2b(int argc, char* argv[]) {
/* Case 2b: flushing stdout does send output to file */
RedirectStdout2File(argv[0]);
printf("Will go to file if flushed\n");
fflush(stdout);
RedirectStdout2File("/dev/null");
}
int main_3(int argc, char* argv[]) {
/* Case 3: printf before redirect; printf is line-buffered after */
printf("Before redirect\n");
RedirectStdout2File(argv[0]);
printf("Does go to file!\n");
RedirectStdout2File("/dev/null");
}
Flushing for stdout
is determined by its buffering behaviour. The buffering can be set to three modes: _IOFBF
(full buffering: waits until fflush()
if possible), _IOLBF
(line buffering: newline triggers automatic flush), and _IONBF
(direct write always used). "Support for these characteristics is implementation-defined, and may be affected via the setbuf()
and setvbuf()
functions." [C99:7.19.3.3]
"At program startup, three text streams are predefined and need not be opened explicitly — standard input (for reading conventional input), standard output (for writing conventional output), and standard error (for writing diagnostic output). As initially opened, the standard error stream is not fully buffered; the standard input and standard output streams are fully buffered if and only if the stream can be determined not to refer to an interactive device." [C99:7.19.3.7]
So, what happens is that the implementation does something platform-specific to decide whether stdout
is going to be line-buffered. In most libc implementations, this test is done when the stream is first used.
printf()
is flushed automatically.fflush()
, unless you write gobloads of data to it.printf()
, stdout acquired the line-buffered mode. When we swap out the fd to go to file, it's still line-buffered, so the data is flushed automatically.Each libc has latitude in how it interprets these requirements, since C99 doesn't specify what an "interactive device" is, nor does POSIX's stdio entry extend this (beyond requiring stderr to be open for reading).
Glibc. See filedoalloc.c:L111. Here we use stat()
to test if the fd is a tty, and set the buffering mode accordingly. (This is called from fileops.c.) stdout
initially has a null buffer, and it's allocated on the first use of the stream based on the characteristics of fd 1.
BSD libc. Very similar, but much cleaner code to follow! See this line in makebuf.c