Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::flush(3)		      C++ Standard Libary		 std::flush(3)

NAME
       std::flush - std::flush

Synopsis
	  Defined in header <ostream>
	  template< class CharT, class Traits >
	  std::basic_ostream<CharT,  Traits>& flush( std::basic_ostream<CharT,
       Traits>&	os );

	  Flushes the output sequence os as if by calling os.flush().

	  This is an output-only I/O manipulator, it may be called with	an ex-
       pression	such as
	  out << std::flush for	any out	of type	std::basic_ostream.

Notes
	  This manipulator may be used to produce an incomplete	line of	output
       immediately,
	  e.g. when displaying output from a long-running process, logging ac-
       tivity of
	  multiple threads or logging activity of a program that may crash un-
       expectedly. An
	  explicit flush of std::cout is  also	necessary  before  a  call  to
       std::system, if the
	  spawned  process  performs  any  screen  I/O	(a  common  example is
       std::system("pause") on
	  Windows). In most other usual	interactive I/O	 scenarios,  std::endl
       is redundant when
	  used	with  std::cout	 because  any  input  from std::cin, output to
       std::cerr, or program
	  termination forces a call to std::cout.flush().

	  When a complete line of output needs to be  flushed,	the  std::endl
       manipulator may be
	  used.

	  When	every  output  operation needs to be flushed, the std::unitbuf
       manipulator may be
	  used.

Parameters
	  os - reference to output stream

Return value
	  os (reference	to the stream after manipulation)

Example
	  Without std::flush, the output would be the same, but	may not	appear
       in real time.

       // Run this code

	#include <iostream>
	#include <chrono>
	template<typename Diff>
	void log_progress(Diff d)
	{
	    std::cout << "..("
		      <<     std::chrono::duration_cast<std::chrono::millisec-
       onds>(d).count()
		      << " ms).." << std::flush;
	}
	int main()
	{
	    volatile int sink=0;

	    auto t1 = std::chrono::high_resolution_clock::now();
	    for(int j=0; j<5; ++j)
	    {
		for(int	n=0; n<10000; ++n)
		    for(int m=0; m<20000; ++m)
			sink +=	m*n; //	do some	work
		auto now = std::chrono::high_resolution_clock::now();
		log_progress(now - t1);
	    }
	    std::cout << '\n';
	}

Possible output:
	..(450 ms)....(901 ms)....(1350	ms)....(1800 ms)....(2250 ms)..

See also
	  unitbuf   controls whether output is flushed after each operation
	  nounitbuf (function)
	  endl	    outputs '\n' and flushes the output	stream
		    (function template)
	  flush	    synchronizes with the underlying storage device
		    (public	 member	    function	 of	std::basic_os-
       tream<CharT,Traits>)

http://cppreference.com		  2022.07.31			 std::flush(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::flush&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help