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.
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.
How to make a simple C++ program in which std::cout is not flushed
This is not standard c++, but in POSIX, you can send a "kill" signal to kill the running process. This will stop the execution without cleanup such as flushing buffers.
Edit: I realized that signals are not only POSIX but actually part of C standard library (and included in the C++ standard library).
#include <csignal>
// ...
std::cout << "Don't write me to the console!";
std::raise(SIGKILL);
std::cout won't print
Make sure you flush the stream. This is required because the output streams are buffered and you have no guarantee over when the buffer will be flushed unless you manually flush it yourself.
std::cout << "Hello" << std::endl;
std::endl
will output a newline and flush the stream. Alternatively, std::flush
will just do the flush. Flushing can also be done using the stream's member function:
std::cout.flush();
Force print to terminal (std::cout is being piped)
I think you can do it following these steps:
Save the redirected buffer
Change buffer to console
Get your job done
Again set buffer to the saved buffer in step 1
For example
#include <sstream>
#include <iostream>
void print_to_console() {
std::cout << "Hello from print_to_console()" << std::endl;
}
void foo(){
std::cout<<"hello world"<<std::endl;
print_to_console(); // this could be printed from anything
}
int main()
{
std::stringstream ss;
//change the underlying buffer and save the old buffer
auto old_buf = std::cout.rdbuf(ss.rdbuf());
foo(); //all the std::cout goes to ss
std::cout.rdbuf(old_buf); //reset
std::cout << "<redirected-output>\n"
<< ss.str()
<< "</redirected-output>" << std::endl;
}
I haven't tested it. I took the idea and example from this accepted answer.
For convenience, you can just write a function to print in console. This function will take care of the redirection and printing.
Why does printf not flush after the call unless a newline is in the format string?
The stdout
stream is line buffered by default, so will only display what's in the buffer after it reaches a newline (or when it's told to). You have a few options to print immediately:
Print to
stderr
instead usingfprintf
(stderr
is unbuffered by default):fprintf(stderr, "I will be printed immediately");
Flush
stdout
whenever you need it to usingfflush
:printf("Buffered, will be flushed");
fflush(stdout); // Will now print everything in the stdout bufferDisable buffering on stdout by using
setbuf
:setbuf(stdout, NULL);
Or use the more flexible
setvbuf
:setvbuf(stdout, NULL, _IONBF, 0);
Related Topics
C++ Template Partial Specialization Member Function
Gdb Complaining About Missing Raise.C
How to Redirect Qdebug, Qwarning, Qcritical etc Output
How to Measure Cpu Time and Wall Clock Time on Both Linux/Windows
C++ Vector Size. Why -1 Is Greater Than Zero
Behavior of Post Increment in Cout
Avoiding Circular Dependencies of Header Files
Difference Between Erase and Remove
Can Any One Provide Me a Sample of Singleton in C++