Selective implicit conversions

Question

I have a Value class which can hold a value of various data types.

class Value
{
    private:
        union
        {
            int Integer;
            double Real;
            bool Boolean;
        };

        ValueTypes valType;

    public:
        Value();
        Value(double Val);
        Value(int Val);
        Value(bool Val);

        /* ... */

        friend std::ostream& operator <<(std::ostream& stream, const Value& val);
}

I would like to overload the << operator, so a value could be printed without the trouble of investigating its type.

This is my current implementation:

std::ostream &operator <<(std::ostream &os, const Value &val)
{
    switch (val.valType)
    {
        case ValueTypes::Real:
            os << val.Real;
            break;

        case ValueTypes::Integer:
            os << val.Integer;
            break;

        case ValueTypes::Boolean:
            os << (val.Boolean ? "True" : "False");
            break;
    }

    return os;
}

First, when compiling with g++ (CodeBlocks IDE, Ubuntu) the implementation causes an implicit conversion to Value. When the value type is either Integer or Real, the os << statement casts them to Value, which then calls to the ostream overload all over again (infinite recursion), so I end up with a segmentation error.

Second, when compiling with Visual C++, the implicit conversion is gone, and it prints the values just fine (Does not call the implicit constructor).

Notes:

I desire to keep the implicit constructors, since it enhances readability and eases maintenance in other sections of my project.

In addition, I found the following blog post, but failed to adjust my code so it will execute as I wish it to (The use of templates was a bit beyond my current understanding of cpp's syntax).

What can I do to disable implicit conversions in the specific ostream overloading function?

EDIT: With -Wall enabled I get no warnings in CodeBlocks.

Which versions of GCC and VC++ are you using? Because one of them is wrong. — Cornstalks, Mar 23 '14 at 00:02
@Cornstalks `gcc version 4.8.1`. About VC++ I am uncertain, I use VS2013. — Novak, Mar 23 '14 at 00:05
Works for me with clang 3.4 and [GCC 4.8.1](http://ideone.com/SUIoWZ). — Cornstalks, Mar 23 '14 at 00:13
I tried it with Ideone, and it works as intended. What could cause this mis-match in the setup of CodeBlocks? — Novak, Mar 23 '14 at 00:25
Note that there's a [`boost::variant`](http://www.boost.org/doc/libs/1_55_0/doc/html/variant.html) class template which does pretty much what you're implementing (as far as I can see). — dyp, Mar 23 '14 at 00:26
Another remark: `os << (val.Boolean ? "True" : "False");` is pretty much identical to `os << std::boolalpha << val.Boolean;`, see [cppreference: boolalpha](http://en.cppreference.com/w/cpp/io/manip/boolalpha) — dyp, Mar 23 '14 at 00:28
A workaround might be to add a `using std::operator<<;` in the function body. — dyp, Mar 23 '14 at 00:30
@dyp with your latest suggestion, the compiler complains it does not find a match for the `<<` operator, for `ostream` and `double`. Perhaps that is why there is an implicit cast? — Novak, Mar 23 '14 at 00:35
That's weird. can you extend your example to an [SSCCE](http://sscce.org)? — dyp, Mar 23 '14 at 00:36
Hmm what headers did you include in the file where the implementation of your `operator<<` resides? — dyp, Mar 23 '14 at 00:39
``, `` and ``. I myself believe it to be something with the compiler flags, because it works perfectly when using other compilers. — Novak, Mar 23 '14 at 00:41
And it works! How does it allow me to use the class it self (`ostream`), but ignores its overloads? I would expect a warning to show. Create an answer, and I'll accept it. — Novak, Mar 23 '14 at 00:53

score 3 · Accepted Answer · edited May 23 '17 at 11:57

You need to #include <ostream>. The reason it doesn't work without that is because that's the header that actually defines std::ostream and all those useful operator<< functions.

The reason it doesn't freak out and complain about "no definition for std::ostream" (or other the << operators) is because of forward declaration. If you forward declare a type, you can use it as a pointer or reference (so long as you don't try to further access it). You can do some things with an incomplete type.

Those other headers you were including were likely forward declaring std::ostream, but never giving a full definition for it and all the << operators. At least on your Ubuntu system. On the other systems, it's possible the other headers could have included <ostream> or at least provided some of the definitions that <ostream> does. Your operator<< was probably the only one the compiler was seeing (because you hadn't included <ostream>), and since it was the only one the compiler knew of, it was trying to use it for everything.

In short, when working on cross platform stuff, one should be pedantic about including exactly what's necessary (and not relying on other headers to include things that aren't related to them).

*"Those other headers you were including were likely forward declaring `std::ostream`"* True. I was guessing the OP only included ``, that's why I asked. `` needs it (at least) for example, as it defines `operator<<` for `std::string`. — dyp, Mar 23 '14 at 01:27

Selective implicit conversions

1 Answers1