IO-manipulators as template parameters? - c++

Question

I'm trying to work with a class, let's call it a stream_wrapper.
It contains a value of (or a reference to) an std::ostream object as one of its fields.
All I want to do is to overload the << operator, so I can use this wrapper like a normal stream.
My first idea was just to write it as a function template.
Example:
class stream_wrapper
{
std::ostream& stream;
template<typename Output>
friend stream_wrapper& operator<<(stream_wrapper& s, Output output)
public:
stream_wrapper(std::ostream& stream) : stream(stream) {}
}
template<typename Output>
stream_wrapper& operator<<(stream_wrapper& s, Output output)
{
s.stream << output;
return s;
}
The idea was that template will be instantiated fine for all types that std::ostream's operator<< works.
This works fine with all usual types, but fails when I attempt to pass some stream manipulator, such as std::endl.
Example:
int main()
{
stream_wrapper s(std::cout);
int a = 1;
double b = 5;
s << a << ' ' << b << '\n'; // WORKS
s << std::endl; // DOESN'T COMPILE
}
This fails, because the compiler can't deduce the type of std::endl.
So, my questions are:
Is there a way to make it work?
What type things like std::endl are?
Thank you!

Answer 1

First off, your overloaded operator<< is missing a return *this; statement.
Second, I/O manipulators are implemented as functions that take a stream object as input. For example, std::endl is declared like this:
template< class CharT, class Traits >
std::basic_ostream<CharT, Traits>& endl( std::basic_ostream<CharT, Traits>& os );
std::basic_ostream has an overloaded operator<< which accepts such a function:
basic_ostream& operator<<(
std::basic_ostream<CharT,Traits>& (*func)(std::basic_ostream<CharT,Traits>&) );
This overload of std::basic_ostream::operator<< will call the func() with *this as the input parameter, eg:
basic_ostream& operator<<(
std::basic_ostream<CharT,Traits>& (*func)(std::basic_ostream<CharT,Traits>&) )
{
return func(*this);
}
This mechanism is what allows std::endl (and other manipulators) to be used with any std::ostream object via operator<<.
So, in your example, s << std::endl does not compile because std::endl is expecting a std::ostream object, not a stream_wrapper object.
To fix this in your wrapper, you will have to add extra overloads of operator<< to handle the various kinds of I/O manipulators that are available, eg:
class stream_wrapper
{
std::ostream& stream;
template<typename Output>
friend stream_wrapper& operator<<(stream_wrapper&, const Output &);
friend stream_wrapper& operator<<(stream_wrapper&, std::ios_base& (*)(std::ios_base&) );
friend stream_wrapper& operator<<(stream_wrapper&, std::ios& (*)(std::ios&) );
friend stream_wrapper& operator<<(stream_wrapper&, std::ostream& (*)(std::ostream&) );
public:
stream_wrapper(std::ostream& stream) : stream(stream) {}
}
template<typename Output>
stream_wrapper& operator<<(stream_wrapper& s, const Output &output)
{
s.stream << output;
return *this;
}
stream_wrapper& operator<<(stream_wrapper& s, std::ios_base& (*func)(std::ios_base&) )
{
s.stream << func;
// or: func(s.stream);
return *this;
}
stream_wrapper& operator<<(stream_wrapper& s, std::ios& (*func)(std::ios&) )
{
s.stream << func;
// or: func(s.stream);
return *this;
}
stream_wrapper& operator<<(stream_wrapper& s, std::ostream& (*func)(std::ostream&) )
{
s.stream << func;
// or: func(s.stream);
return *this;
}