Does std::endl << std::flush have a purpose?

Question

std::flush right after a std::endl is used all over the legacy code I am looking at. When I first saw this, my thought was it is redundant from looking at the description of std::endl and std::flush at:

http://en.cppreference.com/w/cpp/io/manip/endl

http://en.cppreference.com/w/cpp/io/manip/flush

Here is an example of what I am seeing in the legacy source code:

std::cout << "Generic Notification" << std::endl << std::flush;

But, as many senior software developers have seen this code throughout the years, I am wondering if there is some detail I am missing. Is there any purpose to having a std::flush after a std::endl?

if it wasnt `std::cout` but some other stream there might be a reason... — 463035818_is_not_an_ai, Jun 05 '18 at 18:56
@user463035818 And what would that be? `std::endl` is defined as "end line & flush." — Angew is no longer proud of SO, Jun 05 '18 at 18:56
@Angew if I write my own stream that has `operator<<` overloads for `std::endl` and `std::flush` i can make them work any way I want, no? — 463035818_is_not_an_ai, Jun 05 '18 at 18:58
@user463035818 Oh, you meant if it was not a standard stream at all. Yes, then indeed it could make sense (if the stream implementor's logic was twisted enough). I interpreted your comment as comparing `std::cout` to other `std` streams (e.g. a `std::ofstream` instance). — Angew is no longer proud of SO, Jun 05 '18 at 18:59
@Angew I just considered the chance that OP replaced whatever stream it was in the original code with `std::cout` for the sake of a mcve. Of course even for a custom streamlike object the `flush` should not have any use in that place — 463035818_is_not_an_ai, Jun 05 '18 at 19:01
@user463035818 For the mcve I just used std out, but also there are calls to std error in the legacy code that use this std::endl << std::flush. — 9Breaker, Jun 05 '18 at 19:05
my first comment more precise: There might be a reason for the `flush` if it wasnt a standard stream, though it still wouldnt be a good reason, because a stream that does not flush on `endl` can be considered broken — 463035818_is_not_an_ai, Jun 05 '18 at 19:07
maybe just noone ever had the cochones to tell the seniors that this makes no sense ;) — 463035818_is_not_an_ai, Jun 05 '18 at 19:10
@user463035818 haha, after getting the feedback from SO, now I will — 9Breaker, Jun 05 '18 at 19:14
@user463035818: Maybe someone just did `sed -ri 's/std::cout (<< .*);$/std::cout \1 << std::flush;/'` on the source at some point. — einpoklum, Jun 05 '18 at 22:58

score 17 · Accepted Answer · answered Jun 05 '18 at 18:51

17

There's no purpose for it.

If I had to speculate on why your legacy code contains these lines, there are a few possibilities, starting with (what I consider to be) the most probable scenarios:

Someone added the explicit call to std::flush mistakenly, and the senior developers didn't consider it a problem needing fixing
The code originates from a time before the C++ standard was widely adopted, and in that time, the local compiler's implementation of std::endl did not trigger a flush, which meant that your senior developers were (correctly) understanding that it was necessary
An older version of the C++ standard might not have required std::endl to trigger a flush
Your senior developers are mistaken about the behavior of std::endl.
Your execution environment is a strange behemoth that actually requires output to be flushed twice before the desired result can be expected.

answered Jun 05 '18 at 18:51

Xirema

19,889
4
32
68

6

Silly things like this can also appear when text search & replace is performed on source code, such as: replace `<< '\n'`with `<< std::endl` – Drew Dormann Jun 05 '18 at 19:08
2

Good answer, but "an older version of the C++ standard…" – no, C++98 was the first standard, and it did require a `flush`. At best, some early version of the standard library may have behaved differently, though I doubt it. BTW, I can think of a reason why they would use `endl` instead of `'\n’` despite not realizing it flushes, which is a system that does not have LF line terminator (most likely Windows). Of course this is not necessary on `cout`/`cerr`, nor a text mode `ofstream`, and then again `endl` doesn't even help for a binary `ofstream`, but that may have been the mistaken reasoning. – Arne Vogel Jun 05 '18 at 21:17
I particularly like the last scenario. – Kaiserludi Jul 07 '20 at 20:19

einpoklum · Answer 2 · 2023-01-25T20:44:02.947

8

I'll add to the other valid answers that, very often, there isn't a good purpose for neither std::flush nor std::endl.

Basically, std::endl = start a new line + flush the stream. A lot of people, though, tend to end their lines with std::endl because it "sounds right" - end the line. But we actually rarely need to flush the output stream. Sometimes we do (e.g. when we're expecting a user's reply to the string, or it's important to monitor our output with minimal delay) - but that's the exception, not the rule.

So, it might take a bit of getting used to, but we should really default to simply:

std::cout << bunch_of_stuff << '\n';

and that's that!

edited Jan 25 '23 at 20:44

answered Jun 05 '18 at 19:06

einpoklum

118,144
57
340
684

Yes! Use `std::cerr` if you need output to be flushed to a terminal. – Brent Bradburn Jun 06 '18 at 01:27
When testing / debugging it's handy that your output is flushed. – gast128 Jan 25 '23 at 21:33

score 5 · Answer 3 · answered Jun 05 '18 at 18:50

5

In a standards-compliant environment, std::flush serves no useful purpose in this code.

Whoever wrote this either didn't fully understand the semantics of std::endl, or were working around some limitation of their compiler or execution environment.

answered Jun 05 '18 at 18:50

NPE

486,780
108
951
1,012

Does std::endl << std::flush have a purpose?

3 Answers3