自定义 std::ostream 子类中的运算符 << 重载的歧义错误

Question

While trying to develop a class inheriting from both std::stringbuf and std::ostream and giving it a custom operator<<() overload (which should work for this class, but not for std::ostream in general), I got some ambiguity errors I don't understand.

The problems are in the bottom half of the following code. If I remove the operator<<() overload, I do not get any errors ( g++ --std=c++17 -o foo.exe foo.cpp using g++ 9.2.0, MSYS2 build on Windows).

#include <iostream>
#include <ostream>
#include <sstream>

class MyStream:
    private std::stringbuf,
    public std::ostream
{
public:
    MyStream() noexcept:
        std::stringbuf(),
        std::ostream(this)
    {}

    ~MyStream()
    {
        if (pptr() - pbase() < 2)
        { sync(); }
    }

protected:
    virtual int sync() override
    {
        // make sure there actually is something to sync
        if (pptr() - pbase() < 2)
        { return 0; }

        const std::string message{str()};
        const std::size_t length{message.length()};

        // update the pointers for the next sync
        setp(pbase() + length, epptr());

        std::cout << message;

        return std::stringbuf::sync();
    }
};

MyStream& operator<<(MyStream& out, bool boolean) noexcept
{ return out << (boolean ? "yes" : "no"); }
/*           ↑
    more than one operator "<<" matches these operands:
        -- function template "std::basic_ostream<_Elem, _Traits>
            &std::operator<<(std::basic_ostream<_Elem, _Traits> &_Ostr, const char *_Val)"
        -- function template "std::basic_ostream<char, _Traits>
            &std::operator<<(std::basic_ostream<char, _Traits> &_Ostr, const char *_Val)"
        -- function template "std::basic_ostream<_Elem, _Traits>
            &std::operator<<(std::basic_ostream<_Elem, _Traits> &_Ostr, const _Elem *_Val)"
        -- function "operator<<(MyStream &out, bool boolean) noexcept"
        -- operand types are: MyStream << const char *
*/

int main()
{
    MyStream stream;

    stream << "Hello World" << std::endl;
    /*     ↑
        more than one operator "<<" matches these operands:
            -- function template "std::basic_ostream<_Elem, _Traits>
                &std::operator<<(std::basic_ostream<_Elem, _Traits> &_Ostr, const char *_Val)"
            -- function template "std::basic_ostream<char, _Traits>
                &std::operator<<(std::basic_ostream<char, _Traits> &_Ostr, const char *_Val)"
            -- function template "std::basic_ostream<_Elem, _Traits>
                &std::operator<<(std::basic_ostream<_Elem, _Traits> &_Ostr, const _Elem *_Val)"
            -- function "operator<<(MyStream &out, bool boolean) noexcept"
            -- operand types are: MyStream << const char [12]
    */
}

Why is my overload for bool a valid candidate for a char* argument? How can I do this properly?

Answer 1

This seems to work for me under linux (g++ (Ubuntu 7.4.0-1ubuntu1~18.04.1) 7.4.0):

MyStream& operator<<(MyStream& out, bool boolean)
{
    out << (boolean ? "yes" : "no");
    return out;
}

I only changed the return call. That's because out << (boolean? "yes": "no") will use the base ostream operator<< for char* types and hence returns a std::basic_ostream<char> type rather than a MyStream return value type.

And then in main() using a bool type with a MyStream operator<< works:

int main()
{
    MyStream stream;
    bool b=true;

    stream << b << "Hello World" << b << std::endl;  

    //by contrast, this should output "yesHello Worldyes"
    //stream << b << "Hello World";
    //stream << b << std::endl;

    //and so would this kind of ugliness! lol
    //static_cast<MyStream&>(stream << b << "Hello World") << b << std::endl;
}

..but once the base-class ostream operator<< is invoked for the "Hello World" part of the statement, it of course returns a std::basic_ostream<char> type:)

..then after that, because there is no existing ostream operator<< for bool types, the bool b type will get implicitly promoted to a int and so the output is:

yesHello World1 !

---

Windows builds

But you seemed to be getting other errors. So while i do not have MSYS2 to hand, i did try to compile the codes on a WinOS with Visual Studio. In my case, at least, your main() fails immediately due to ambiguities raised by the VS STL implementation:

int main()
{
    MyStream stream;
    stream << "Hello World" << std::endl;
}

No need to cast doubt on your current approach as that has already happened in comments. but just in an attempt to answer your questions; then one way round would be to implement another operator<< for MyStream that handles char* types:

#include <iostream>
#include <ostream>
#include <sstream>

class MyStream:
    private std::stringbuf,
    public std::ostream
{
public:
    MyStream() noexcept:
        std::stringbuf(),
        std::ostream(this)
    {}

    ~MyStream()
    {
        if (pptr() - pbase() < 2)
        { sync(); }
    }

protected:
    virtual int sync() override
    {
        // make sure there actually is something to sync
        if (pptr() - pbase() < 2)
        { return 0; }

        const std::string message{str()};
        const std::size_t length{message.length()};

        // update the pointers for the next sync
        setp(pbase() + length, epptr());

        std::cout << message;

        return std::stringbuf::sync();
    }
};

MyStream& operator<<(MyStream& out, const char* str)
{
    static_cast<std::ostream&>(out) << str;
    return out;
}

MyStream& operator<<(MyStream& out, bool boolean) noexcept
{ return out << (boolean ? "yes" : "no"); }


int main()
{
    MyStream stream;
    bool b=1;      
    stream << b << " oook " << b << std::endl;    
}

Alternatively, since MyStream actually is derived from ostream then we can make use of any operator<< for the ostream type with an explicit cast. For example:

#include <iostream>
#include <ostream>
#include <sstream>

class MyStream:
    private std::stringbuf,
    public std::ostream
{
public:
    MyStream() noexcept:
        std::stringbuf(),
        std::ostream(this)
    {}

    ~MyStream()
    {
        if (pptr() - pbase() < 2)
        { sync(); }
    }

protected:
    virtual int sync() override
    {
        // make sure there actually is something to sync
        if (pptr() - pbase() < 2)
        { return 0; }

        const std::string message{str()};
        const std::size_t length{message.length()};

        // update the pointers for the next sync
        setp(pbase() + length, epptr());

        std::cout << message;

        return std::stringbuf::sync();
    }
};

std::ostream& operator<<(MyStream& out, bool boolean) noexcept
{
    return static_cast<std::ostream&>(out) << (boolean ? "yes" : "no");
}

int main()
{
    MyStream stream;
    bool b=1;

    stream << b << " ooOok ";
    stream << b << std::endl;
}

where the output is hopefully:

yes ooOok yes