The consequences and pros/cons of flushing the stream in c++

Question

I have recently read an article which stated that using \n is preferable to using std::endl because endl also flushes the stream.
But when I looked for a bit more information on the topic I found a site which stated:

If you are in a situation where you have to avoid buffering, you can use std::endl instead of ‘\n’

Now here comes my question: In which situation is it preferable not to write to the buffer? Because I only saw advantages of that technique. Isn't it also safer to write to the buffer? Because it is smaller than a hard drive it will get overwritten faster than data that is stored on the HD (I am not sure if this is true).

Answer 1

When buffering occurs you will have no guarantees that the data is immediately received before a flush occurs. Under particular circumstances you might experience wrong output ordering and/or loss of information/debug data, e.g.

int main() {         std::cout << "This text is quite nice and might as well be buffered";     raise(SIGSEGV); // Oh dear.. segmentation violation     std::cout << std::endl; } 

Live Example

Output:

bash: line 7: 22235 Segmentation fault      (core dumped) ./a.out 

the above will not print any text since the buffering prevented the right output to be displayed.

Now if you simply add a flushing std::endl at the end of the buffer this is what you get

int main() {         std::cout << "This text is quite nice and might as well be buffered" << std::endl;     raise(SIGSEGV); // Oh dear.. segmentation violation     std::cout << std::endl; } 

Live Example

Output:

This text is quite nice and might as well be buffered bash: line 7: 22444 Segmentation fault      (core dumped) ./a.out 

This time the output is visible before the program termination.

Implications of this fact are manifold. Purely speculative: if the data were related to a server log, your app could have crashed before the actual logging.

Answer 2

It will be preferable in any situation in which you want the output to actually appear exactly when it was supposed to appear.

A simple example:

#include <iostream>
int main() {
    std::cout << "Please enter your name: " << std::endl;
    std::string name;
    std::cin >> name;
    ...
}

With buffering, no text will appear on screen before the user is expected to type his/her name, so the user will be confused. (Note that in fact it might be really difficult or impossible to get this example run with buffering fully enabled, as C++ might take special measures to flush std::cout before any input from std::cin, see Why do we need to tie std::cin and std::cout?. But this is just a theoretical example: in case the buffering is fully enabled, the user will not see the prompt.)

Such a situation can occur from time to time, though it might not be very often. Consider writing to a pipe to interact with another process. Or even if your program writes to log file and you personally look into the log file from time to time to see how it runs --- in case of buffering, you usually will not see the output that has been printed from program, but still stays in the buffer yet.

Another important situation to account for --- if your program severely crashes, the buffer contents might not end on the hard drive at all. (I expect the stream destructors to flush the buffer, but a crash can be so severe that no destructors will be called at all.)

Answer 3

It is preferable to flush the buffer if you need the target of your stream to receive the data before the stream is closed.

A real-life example would be an application log, written from a stream that's always open... You may want to look at this log while the program is still running.