Handling std::endl without std::ostream

I am working on an alternative implementation of input/output streams that have similar semantics to std::istream and std::ostream (for size reasons - on my microcontroller instantiating an std::iostream uses up 140KB, or roughly half of my available flash memory).

One thing I really want to support is using std::endl for a more seamless experience for users of my library, who will most likely already have experience using std::iostream. I understand that it will be hacky, but is there a standard compliant way of doing that?

According to cppreference std::endl is defined like this:

Code:

---

template< class CharT, class Traits >
std::basic_ostream<CharT, Traits>& endl( std::basic_ostream<CharT, Traits>& os );

---

So technically I think I can add an overload to my library like this:

Code:

---

MyStream& operator<<(std::function<std::ostream&(std::ostream&)> f) {
  ...
}

---

But then how would I be able to tell that it's endl vs any other io manipulator (which I don't want/need to support)?

Thanks

Why not create your own equivalent of the endl manipulator?

Quote:

---

Originally Posted by laserlight

Why not create your own equivalent of the endl manipulator?

---

Because many of the users of my libraries will be reasonably new to C++, so I want to make it behave as much like std::iostream as possible, for simple use cases, from the user's perspective.

Well, you can call your manipulator endl if you want.

Quote:

---

Originally Posted by laserlight

Well, you can call your manipulator endl if you want.

---

Yeah but then when they try << std::endl, they get a cryptic error message, since most people don't actually know how IO manipulators work under the hood - a function pointer that takes a pointer to ostream as an argument, and the operator overload just calls it on 'this'. I didn't know that until this morning and I've been writing a lot of C++ for years. Most people probably think it's a (non-function) literal of some sort that the stream does something to itself when it sees one, and the error message wouldn't make any sense.

Quote:

---

Originally Posted by cyberfish

Yeah but then when they try << std::endl, they get a cryptic error message, since most people don't actually know how IO manipulators work under the hood - a function pointer that takes a pointer to ostream as an argument, and the operator overload just calls it on 'this'. I didn't know that until this morning and I've been writing a lot of C++ for years. Most people probably think it's a (non-function) literal of some sort that the stream does something to itself when it sees one, and the error message wouldn't make any sense.

---

Cynically, I'd say that until we have template concepts (due to be standardised in C++20), cryptic error messages are just the way of a C++ programmer's life ;)

That said, what you could try is to overload, then check that std::endl is used with either an assert (but not static_assert, so you have to hope for adequate testing), or by throwing an exception otherwise. I'd still be inclined to define a manipulator for your stream type, then overload to prevent the usage of ostream manipulators, otherwise it is confusing as to why one standard manipulator is permitted but not others. I'm afraid that I don't have an example though: the overload may be more tricky than you envisioned because as specified in the standard, std::endl is a function template.

Yeah that would be nice!

This is a whole 'nother level of hacky, but it worked!

Code:

---

BufferedOutputStream& operator<<(
    std::ostream& (*manipulator)(std::ostream&)) {
  using char_type = std::ostream::char_type;
  using traits_type = std::ostream::traits_type;
  if (manipulator == &std::endl<char_type, traits_type>) {
    EnqueueOutput("\n", 1);
    Flush();
  } else if (manipulator == &std::flush<char_type, traits_type>) {
    Flush();
  }
  return *this;
}

---