stream operators where lhs is not a std::iostream instance

Question

I have a custom output class that has two std::ostream members that serve different purposes. Either stream is used depending upon how the output class is configured. In some instances, the two streams are chained together. A grossly simplified version of the class is below. I can provide some more details if needed.

class c_Output
{
  public:
    c_Output (bool x_useA) : m_useA(x_useA) { /* setup m_stream[AB] here */ };
    ~c_Output ();
    inline std::ostream& stream () { return (m_useA ? m_streamA : m_streamB); };

  private:
    bool m_useA;
    std::ostream m_streamA;
    std::ostream m_streamB;
}

I know how to write stream operators for classes that I wish to stream to/from std::cout , std::cin , or any other std::iostream , but I am struggling to write stream operators where a c_Output instance serves as the lhs instead of a std::ostream instance.

Right now, I am able to get away with:

c_Output l_output;
uint64_t l_value = 0xc001c0de;
l_output.stream() << std::hex << std::setw(16) << std::setfill('0') << l_value;

c_Output::stream() returns the appropriate std::ostream& , so this behaves just as expected.

I would like to rewrite the above as:

c_Output l_output;
uint64_t l_value = 0xc001c0de;
l_output << std::hex << std::setw(16) << std::setfill('0') << l_value;

I have attempted several different versions of defining operator<< based on examples I have seen here on StackOverflow and the greater web to no avail. The latest version looks like this:

// in header
class c_Output
{
    ...
    friend c_Output& operator<< (c_Output& x_output, std::ostream& x_stream);
    ...
}

// in source
c_Output&
operator<< (c_Output& x_output, std::ostream& x_stream)
{
    x_output.stream() << x_stream;
    return x_output;
}

The setup of the arguments is intended to mirror the standard stream operator overload. This setup gives me compile issues such as:

error: no match for 'operator<<' in 'l_output << std::hex'
note: candidates are: c_Output& operator<<(c_Output&, std::ostream&)

I have stripped away all the file and line information, but it gets the point across. I am obviously getting the type for the rhs of the operator incorrect. What is the correct type and/or correct means of implementing the stream operator as desired?

There is also a complementary c_Input class that has a similar requirement, but adapting the answer for c_Output should be trivial.

Answer 1

The type of std::hex is std::ios_base& (*)(std::ios_base&) . Change your operator signature to:

c_Output& operator<< (c_Output& x_output, std::ios_base& (*x_stream)(std::ios_base&));

Answer 2

operator<< (c_Output& x_output, std::ostream& x_stream)

The only real problem is that std::hex isn't a std::ostream , and with your methods no overloaded << is available for it.

In order to support the usage of the hex modifier, you'll need another friend overload with parameters (c_Output&, ios_base& (*)(ios_base&)) (as hex is a pointer to function taking reference to ios_base returning reference to ios_base ).

At the rate you're going, you'll need to also implement all the other << overloads as well. This is not a trivial task, but is necessary to masquerade as a std::ostream , with or without inheriting from it.