How does std::flush work?
Since it wasn't answered what std::flush
happens to be, here is some detail on what it actually is. std::flush
is a manipulator, i.e., a function with a specific signature. To start off simple, you can think of std::flush
of having the signature
std::ostream& std::flush(std::ostream&);
The reality is a bit more complex, though (if you are interested, it is explained below as well).
The stream class overload output operators taking operators of this form, i.e., there is a member function taking a manipulator as argument. The output operator calls the manipulator with the object itself:
std::ostream& std::ostream::operator<< (std::ostream& (*manip)(std::ostream&)) {
(*manip)(*this);
return *this;
}
That is, when you "output" std::flush
with to an std::ostream
, it just calls the corresponding function, i.e., the following two statements are equivalent:
std::cout << std::flush;
std::flush(std::cout);
Now, std::flush()
itself is fairly simple: All it does is to call std::ostream::flush()
, i.e., you can envision its implementation to look something like this:
std::ostream& std::flush(std::ostream& out) {
out.flush();
return out;
}
The std::ostream::flush()
function technically calls std::streambuf::pubsync()
on the stream buffer (if any) which is associated with the stream: The stream buffer is responsible for buffering characters and sending characters to the external destination when the used buffer would overflow or when the internal representation should be synced with the external destination, i.e., when the data is to be flushed. On a sequential stream syncing with the external destination just means that any buffered characters are immediately sent. That is, using std::flush
causes the stream buffer to flush its output buffer. For example, when data is written to a console flushing causes the characters to appear at this point on the console.
This may raise the question: Why aren't characters immediately written? The simple answer is that writing characters is generally fairly slow. However, the amount of time it takes to write a reasonable amount of characters is essentially identical to writing just one where. The amount of characters depends on many characteristics of the operating system, file systems, etc. but often up to something like 4k characters are written in about the same time as just one character. Thus, buffering characters up before sending them using a buffer depending on the details of the external destination can be a huge performance improvement.
The above should answer two of your three questions. The remaining question is: When would you flush a stream? The answer is: When the characters should be written to the external destination! This may be at the end of writing a file (closing a file implicitly flushes the buffer, though) or immediately before asking for user input (note that std::cout
is automatically flushed when reading from std::cin
as std::cout
is std::istream::tie()
'd to std::cin
). Although there may be a few occasions where you explicitly want to flush a stream, I find them to be fairly rare.
Finally, I promised to give a full picture of what std::flush
actually is: The streams are class templates capable of dealing with different character types (in practice they work with char
and wchar_t
; making them work with another characters is quite involved although doable if you are really determined). To be able to use std::flush
with all instantiations of streams, it happens to be a function template with a signature like this:
template <typename cT, typename Traits>
std::basic_ostream<cT, Traits>& std::flush(std::basic_ostream<cT, Traits>&);
When using std::flush
immediately with an instantiation of std::basic_ostream
it doesn't really matter: The compiler deduces the template arguments automatically. However, in cases where this function isn't mentioned together with something facilitating the template argument deduction, the compiler will fail to deduce the template arguments.
Does std::endl << std::flush have a purpose?
There's no purpose for it.
If I had to speculate on why your legacy code contains these lines, there are a few possibilities, starting with (what I consider to be) the most probable scenarios:
- Someone added the explicit call to
std::flush
mistakenly, and the senior developers didn't consider it a problem needing fixing - The code originates from a time before the C++ standard was widely adopted, and in that time, the local compiler's implementation of
std::endl
did not trigger a flush, which meant that your senior developers were (correctly) understanding that it was necessary - An older version of the C++ standard might not have required
std::endl
to trigger a flush - Your senior developers are mistaken about the behavior of
std::endl
. - Your execution environment is a strange behemoth that actually requires output to be flushed twice before the desired result can be expected.
Should C++ programmers use std::flush frequently?
Your average program does not require frequent flushing. Flushing is something nearer to a special case needed in a few situations:
- Interacting with a human or other system: flushing output before waiting for input is sensible.
- Going dormant for awhile: Flushing before extended sleep or waiting simplifies examination of logfiles, makes databases consistent most of the time, etc.
If buffering is not needed, it would be better to disable buffering in the first place instead of throwing in a lot of flushes.
Most of the time, programs benefit by having buffering enabled. Sometimes they generate a few characters here and there. Other times they output a blast of lines.
In all my decades of engineering, my most dramatic performance increases are often realized simply by improving buffering. Sometimes by increasing the default FILE
buffer size above 512 bytes (the default) to 4K or 32K (sometimes higher). Other times by adding a layer of buffering or caching. Usually there is high overhead with each trip through the operating system's i/o system. Reducing the total number of system calls is (usually) an easy and highly effective scheme to improve performance.
Why does `\n` flush std::cout?
Yes, endl
will cause a flush, but that doesn't mean the buffer can't decide to flush itself for other reasons. See this reference, particularly this:
In many implementations, standard output is line-buffered, and writing '\n' causes a flush anyway
Is it possible to make std::cout flush automatically before program termination in various failure cases (e.g., exception)
When program terminates due to uncaught exception, std::terminate
will be called. This calls the terminate handler that has been registered using std::set_terminate
. Within this terminate handler, you can flush the standard output streams.
std::terminate
is also called in some other cases such as throwing exception out of noexcept
function, destruction of joinable std::thread
, direct call from user code etc.
This does not help if the program is terminated by the operating system. That can only be solved by disabling buffering. You could try to flush in a signal handler as a desperate measure, but that is not guaranteed to succeed, nor to have desired behaviour, because flushing is not async safe operation.
c++ force std::cout flush (print to screen)
Just insert std::flush
:
std::cout << "Beginning computations..." << std::flush;
Also note that inserting std::endl
will also flush after writing a newline.
stdout and need to flush it C++
To add to the other answers: your debugging statements should instead go to cerr
, because:
- it writes to the standard error, which means that, running the application, you can easily separate the "normal" program output from the errors/debug information via redirection;
- most importantly,
cerr
by default is unbuffered, which means that, after each output operation, it will automatically flush itself, and in general this is desirable for errors and debug output.
(source: C++ standard, §27.3.1 ¶4-5, §27.4.2.1.2 table 83)
Buffer flushing: \n vs. std::endl
Using '\n' does not flush the buffer and is indeed faster than using std::endl.
In typical I/O, output is buffered before it's written to the intended device. This way, when writing to slow to access devices(like files), it doesn't have to access the device after every single character. Flushing "flushes" the buffer onto the device, causing a definite performance overhead.
-Adapted from: C++ - endl and flushing the buffer
Related Topics
How to Output Coloured Text to a Linux Terminal
How to Get Memory Usage At Runtime Using C++
How to Compile a 64-Bit Application Using Visual C++ 2010 Express
Deprecated Header ≪Codecvt≫ Replacement
How to Forward Declare an Inner Class
Static Member Initialization in a Class Template
Atomic Double Floating Point or Sse/Avx Vector Load/Store on X86_64
Read Numeric Data from a Text File in C++
Return Statement VS Exit() in Main()
How to Call a Base Class'S Virtual Function If I'M Overriding It
Why Is Conversion from String Constant to 'Char*' Valid in C But Invalid in C++
Why Is Std::Map Implemented as a Red-Black Tree
Constants and Compiler Optimization in C++
What's "Wrong" With C++ Wchar_T and Wstrings? What Are Some Alternatives to Wide Characters