Thread: 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

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.

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.

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;
}