# std::flush

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

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

## Official Specification Summary (cppreference)

```cpp
// 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 expression 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 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()`.

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.

```cpp
#include <chrono>
#include <iostream>

template<typename Diff>
void log_progress(Diff d)
{
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(d) << " ... "
              << 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:

```text
567ms ... 1137ms ... 1707ms ... 2269ms ... 2842ms ...
```

### 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)
- [`endl`](https://en.cppreference.com/w/cpp/io/manip/endl): outputs `'\n'` and 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/flush (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.