< cpp‎ | io‎ | manip
Revision as of 06:53, 19 December 2012 by Cubbi (Talk | contribs)

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

Inserts a endline 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 expression such as out << std::endl for any out of type std::basic_ostream.



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 multiple threads or logging activity of a program that may crash unexpectedly. 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(). Use of std::endl in place of '\n', encouraged by some sources, may significantly degrade output performance.

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

The code samples on this wiki follow Bjarne Stroustrup 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 manipulator may be used.


os - reference to output stream

Return value

os (reference to the stream after manipulation)


With \n instead of endl, the output would be the same, but may not appear in real time.

#include <iostream>
#include <chrono>
template<typename Diff>
void log_progress(Diff d)
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(d).count()
              << " ms passed" << std::endl;
int main()
    std::cout.sync_with_stdio(false); // on some platforms, stdout flushes on \n
    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);


487 ms passed
974 ms passed
1470 ms passed
1965 ms passed
2455 ms passed

See also

Template:cpp/io/manip/dcl list unitbufTemplate:cpp/io/manip/dcl list flushTemplate:cpp/io/basic ostream/dcl list flush