# std::endl

> C++ Atlas: `cppatlas.com/w/cpp/io/manip/endl` | Source: https://en.cppreference.com/w/cpp/io/manip/endl | Domain: Input/output

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().

## Official Specification Summary (cppreference)

```cpp
// 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 expression 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 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. 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::ios::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 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` manipulator 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 appear in real time.

```cpp
#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:

```text
566ms passed
1133ms passed
1699ms passed
2262ms passed
2829ms passed
```

### See also

- [`unitbuf`](https://en.cppreference.com/w/cpp/io/manip/unitbuf), [`nounitbuf`](https://en.cppreference.com/w/cpp/io/manip/unitbuf): controls whether output is flushed after each operation (function)
- [`flush`](https://en.cppreference.com/w/cpp/io/manip/flush): flushes the output stream (function template)
- [`flush`](https://en.cppreference.com/w/cpp/io/basic_ostream/flush): synchronizes with the underlying storage device (public member function of `std::basic_ostream<CharT,Traits>`)

---
Attribution: content from https://en.cppreference.com/w/cpp/io/manip/endl (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.