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

NAME
     std::endl - std::endl

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

	Inserts a newline character into the output sequence os and  flushes  it
     as if by
	calling os.put(os.widen('\n')) followed by os.flush().

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

Notes
	This  manipulator  may	be used to produce a line of output immediately,
     e.g. when
	displaying output from a long-running process, logging activity of  mul-
     tiple threads
	or  logging  activity  of  a program that may crash unexpectedly. An ex-
     plicit flush of
	std::cout is also necessary before a call to std::system, if the spawned
     process
	performs any screen I/O. In most other usual interactive I/O  scenarios,
     std::endl is
	redundant when used with std::cout because any input from std::cin, out-
     put to
	std::cerr,  or	program  termination forces a call to std::cout.flush().
     Use of
	std::endl in place of '\n', encouraged by  some  sources,  may	signifi-
     cantly degrade
	output performance.

	In  many  implementations, standard output is line-buffered, and writing
     '\n' causes a
	flush anyway, unless std::ios::sync_with_stdio(false) was  executed.  In
     those
	situations,  unnecessary endl only degrades the performance of file out-
     put, not
	standard output.

	The code samples on this wiki follow Bjarne Stroustrup and The C++  Core
     Guidelines
	in flushing the standard output only where necessary.

	When  an  incomplete  line of output needs to be flushed, the std::flush
     manipulator
	may be used.

	When every character of output needs to be flushed, the std::unitbuf ma-
     nipulator may
	be used.

Parameters
	os - reference to output stream

Return value
	os (reference to the stream after manipulation).

Example
	With '\n' instead of endl, the output would be the same, but may not ap-
     pear in real
	time.

     // Run this code

      #include <chrono>
      #include <iostream>

      template<typename Diff>
      void log_progress(Diff d)
      {
	  std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(d)
		    << " passed" << std::endl;
      }

      int main()
      {
	  std::cout.sync_with_stdio(false); // on some platforms, stdout flushes
     on \n

	  static volatile int sink{};
	  const auto t1 = std::chrono::high_resolution_clock::now();
	  for (int i = 0; i < 5; ++i)
	  {
	      for (int j = 0; j < 10000; ++j)
		  for (int k = 0; k < 20000; ++k)
		      sink += i * j * k; // do some work
	      log_progress(std::chrono::high_resolution_clock::now() - t1);
	  }
      }

Possible output:
      566ms passed
      1133ms passed
      1699ms passed
      2262ms passed
      2829ms passed

See also
	unitbuf   controls whether output is flushed after each operation
	nounitbuf (function)
	flush	  flushes the output stream
		  (function template)
	flush	  synchronizes with the underlying storage device
		  (public member function of std::basic_ostream<CharT,Traits>)

http://cppreference.com 	   2024.06.10			    std::endl(3)
home | help