Does new line character also flush the buffer?

The default setup for the standard C++ stream objects (std::cin, std::cout, std::cerr, and std::clog) is that they are synchronized with the corresponding C streams (stdin, stdout, and stderr). Synchronization means that alternating access of the C++ and the C streams results in consistent behaviour. For example, this code is expected to produce the string hello, world:

std::cout << "hel"; fprintf(stdout, "lo,"); std::cout << " wo"; fprintf(stdout, "rld"); 

The C++ standard makes no mandate on how this synchronization is implemented. One way to implement it is to disable any buffering for std::cout (and family) and immediately access stdout. That is, the above example could immediately write the individual characters to stdout.

If the characters are actually written to stdout the default setting for the buffering mode for stdout would be used. I can't find a specification in the standard but typically the default for the buffering mode of stdout is _IOLBF when it is connected to an interactive stream (e.g., a console), i.e., the buffer is flushed at the end of lines. The default for writing to a file is typically _IOFBF, i.e., the output is flushed when a complete buffer is written. As a result, writing a newline to std::cout could result in the buffer being flushed.

The streams in C++ are normally set up to be buffered. That is, writing a newline to a file will generally not cause the output to appear immediately (it would only appear immediately if the character caused the buffer to overflow the stream is set to be unbuffered). Since the synchronization with stdout is often unnecessary, e.g., when a program always uses std::cout to write to the standard output, but does cause output to the standard output to be slowed down quite dramatically (disabling buffering for stream makes them slow) the synchronization can be disabled:

std::ios_base::sync_with_stdio(false); 

This disables synchronization for all stream objects. For a bad implementation there could be no effect while a good implementation will enable buffering for std::cout resulting in a substantial speed-up and probably also disabling line buffering.

Once a C++ stream is buffered, there is no built-in way to cause it to be flushed when a newline is written. The primary reason for this is that dealing with line buffering would require inspection of each character by the stream buffer which effectively inhibits bulk operations on characters and thereby causing a substantial slow-down. If needed, line buffering can be implemented through a simple filtering stream buffer. For example:

class linebuf: public std::streambuf { std::streambuf* sbuf; public: linebuf(std::streambuf* sbuf): sbuf(sbuf) {} int_type overflow(int_type c) { int rc = this->sbuf->sputc(c); this->sbuf->pubsync(); return rc; } int sync() { return this->sbuf->pubsync(); } }; // ... int main() { std::ios_base::sync_with_stdio(false); linebuf sbuf(std::cout.rdbuf()); std::streambuf* origcout = std::cout.rdbuf(&sbuf); std::cout << "line\nbuffered\n"; std::cout.rdbuf(origcout); // needed for clean-up; } 

tl;dr: the C++ standard doesn't have a concept of line buffering but it may get it when standard I/O is synchronized from C's behaviour of stdout.

Generally there is a sync between C style I/O and C++ style I/O. And is by default enabled in C++. The reason for sync is to maintain order of operations. When sync in enabled, they internally have this shared buffering strategy.

stdout is line buffered(destination is terminal) i.e., it flushes(writes to the destination) it's buffer when it encounters '\n'. Since by default there is this sync between stdout and cout and also that they share the buffer is the reason why '\n' is also causing buffer flushing when used in cout.

#include <unistd.h> #include <iostream> using namespace std; int main(){ cout << "Hello\nWorld"; sleep(2); return 0; } 

In the above code, there is a sync between stdout and cout, so they share buffer internally. Since stdout is line buffered as the target is terminal, stdout flushes it's buffer when it encounter's '\n' which also causes cout to flush as buffer is shared. So that is the reason you see "Hello" printed first and then after 2 seconds you see "World" printed.

If you were to turn off the sync with c stream, then cout works independently with it's own buffering scheme.

#include <unistd.h> #include <iostream> using namespace std; int main(){ ios::sync_with_stdio(false); // disable sync between c++ stream and c stream cout << "Hello\nWorld"; sleep(2); return 0; } 

Now, as the sync with c stream is disabled the cout has it's own buffer and buffering strategy and no longer flushes buffer in response to '\n'. So you would see "Hello" and "World" printed immediately and then 2 seconds later the program exits.

endl causes cout to flush irrespective of the destination or target.