Using a << operator inside an overloaded << operator

Question

I'm writing a class that overloads the << and >> operator similar to std::istream and std::ostream. The first few functions worked as desired. However, I want to use other std::*stream classes inside my own class for formatting purposes, and this causes an interesting, I would say, 'recursive' compiler issue:

class SmartStream
{
public:
    template <typename F> friend F &operator << (F &in, float f)
    {
        in.type ("f");
        in.m_buf.str ("");
        in.m_buf << f;          // This causes a 'recursive' compile call
        in.add (in.m_buf.str ());
        return in;
    }

protected:
    std::ostringstream m_buf;

    void type(const std::string &_type) {};
    void add(const std::string &) {};
};

The actual error is long but it starts like this:

rec_stream.cpp: In instantiation of 'F& operator<<(F&, float) [with F = std::basic_ostringstream<char>]':
rec_stream.cpp:14:18:   required from 'F& operator<<(F&, float) [with F = ExtraStream]'
rec_stream.cpp:60:11:   required from here
rec_stream.cpp:12:9: error: 'class std::basic_ostringstream<char>' has no member named 'type'
         in.type ("f");
         ^

So apparently the compiler applies the same overloaded << operator to the m_buf variable of type std::ostringstream, but of course that doesn't have type() and add() functions. After reading the answer to this question that kinda makes sense, but doesn't provide a solution.

No before you say, use this in SmartStream:

class SmartStream 
{
   ....
    SmartStream &operator << (float f)
    {
        type("f");
        m_buf.str ("");
        m_buf << f;     // Ambiguous overload
        add( m_buf.str ());
        return *this;
    }
};

There are two problems. First, as noted in the code, that triggers an ambiguous overload. Second, consider the following:

class ExtraStream: public SmartStream
{
public:
    template <typename F> friend F &operator << (F &in, struct tm t)
    {
        in.type ("tm");
        in.m_buf.str ("");
        in.m_buf << t.tm_hour; // Ambiguous overload
        in.add (in.m_buf.str ());
        return in;
    }
};

Indeed, I am extending SmartStream to handle custom types using the mechanism laid out in that class. Using the non-friend operator will not allow me to do this:

ExtraStream es;

struct tm t1, t2;
float f1, f2;

es << f1 << t1 << f2 << t2; // works

Because after a << (float) the return type is SmartStream which does not know how to handle struct tms.

My question:

Is there a way to convince the compiler (gcc 4.8.2) to use the 'base' << operator for std::ostringstream and not the overloaded one? I tried various casts, :: resolution operators, moving the code with in.m_buf << f; to a non-templated function in SmartStream but nothing helped.

Also, why does it only use this inside the template operator << function? Any use of << on std::ostringstream outside of that function works as expected.

I have only glanced over your code but did you try `in.m_buf.ostrongstream::operator<<(f)`? Note that you'll need a `using` directive because member access cannot be namespace qualified. — 5gon12eder, Jan 14 '15 at 21:20
The original code [compiles fine with clang++](http://coliru.stacked-crooked.com/a/7f8df67973a9d8de). — dyp, Jan 14 '15 at 21:24
Your template friends are too general, they take anything, be more more specific there. — , Jan 14 '15 at 21:27
@dyp: Interesting. https://gist.github.com/sharth/6b09bd9e5aca4585370c compiles fine with clang++ but fails with g++ 4.9.0... — Bill Lynch, Jan 14 '15 at 21:28
@5gon12eder: well, neither `in.m_buf::ostringstream::operator << f` and `in.m_buf.ostringstream::operator << f` work. Unless you can specify the correct `using` directive, `using std::ostringstream::operator<<` won't work (and I'm not sure that's even possible since it's an operator, not a function) — JvO, Jan 14 '15 at 21:33
@dyp Interesting. So maybe I found a bug in GCC? That would be cool... :) — JvO, Jan 14 '15 at 21:35
@BillLynch That's a really weird error message. I don't even know how to interpret the code, given that you're using compound literals, which are not legal in C++. gcc's error message seems to imply that the elaborate-type-specifier redeclares the `tm` from the C StdLib. — dyp, Jan 14 '15 at 21:35
@5gon12eder Unfortunately, that does not do the trick... Added the `using` to the function and tried various combinations of '.' and '::'; I guess the compiler really doesn't know what overload to pick. — JvO, Jan 14 '15 at 21:51
@Oktalist That part makes sense to me: given an instance of a derived class `DerivedClass d;` that doesn't attempt to change the `operator<<` implementation, you'd probably still want `d << 1.0f` to return `DerivedClass &`, not `SmartStream &`. — , Jan 15 '15 at 10:37
In that case, @BillLynch's answer is exactly what is called for. If it seems kinda hacky, well, that's what was asked for. — Oktalist, Jan 15 '15 at 15:15

JvO · Accepted Answer · 2015-01-15T16:25:16.490

I posted this on the gcc buglist since I felt this is a bug or at least an ambiguity in the C++ reference. Jonathan Wakely came up with a surprisingly simple solution:

template <typename F> friend F &operator << (F &in, float f)
{
    in.type ("f");
    in.m_buf.str ("");
    using std::operator <<;  // indicate proper operator in the next line
    in.m_buf << f;          
    in.add (in.m_buf.str ());
    return in;
}

So indeed it required a using clause, just one I wouldn't expect.

score 0 · Answer 2 · answered Jan 14 '15 at 21:36

So, I think the simplest thing would be to restrict the friend functions with something like std::enable_if so that they are only valid on streams that have the correct parent class.

#include <sstream>
#include <type_traits>

class SmartStream {
    public:
        template <typename F>
        friend typename std::enable_if<std::is_base_of<SmartStream, F>::value, F&>::type
        operator << (F &in, float f) {
            in.type("f");
            in.m_buf.str("");
            in.m_buf << f;
            in.add (in.m_buf.str ());
            return in;
        }

    protected:
        std::ostringstream m_buf;

        void type(const std::string &_type) {};
        void add(const std::string &) {};
};

class ExtraStream: public SmartStream {
    public:
        template <typename F>
        friend typename std::enable_if<std::is_base_of<ExtraStream, F>::value, F&>::type
        operator << (F &in, struct tm t) {
            in.type ("tm");
            in.m_buf.str ("");
            in.m_buf << t.tm_hour;
            in.add (in.m_buf.str ());
            return in;
        }
};

int main() {
    SmartStream ss;
    ExtraStream es;
    struct tm t;

    ss << 3.14f;
    es << 3.14f << t << 3.14;
    // ss << t; // Fails as expected.
}

It's kinda hacky, and requires (for gcc 4.8 at least) enabling the experimental C++11 features, but it works. — JvO, Jan 14 '15 at 21:57
@JvO: `enable_if` exists in boost for pre c++11 compilers, and you could always create a private implementation as well. (It doesn't depend on any new compiler features to implement). — Bill Lynch, Jan 14 '15 at 21:59
This is also necessary in case you want to use `std::cout << 1.0f` in any member function of `SmartStream`. — Oktalist, Jan 15 '15 at 15:18

Using a << operator inside an overloaded << operator

2 Answers2