Type conversion in ostream& operator <<

Question

I have a class entry and an ostream& operator << overwritten for it. I also have an auxiliary class cursor and a type conversion operator entry(). Then, in my main() function I have the following expression:

cout << data[4];

where data[4] is a cursor, but compilation fails with

error: invalid operands to binary expression

What I want is for a compiler to convert data[4] to entry and to use its << operator. Is there any way to call this ostream operator in an aforementioned way without having to add special methods to entry?

Here are some pieces of code:

    class entry
    {
        friend class cursor;
        /*here comes some data*/

    public:    

        friend ostream& operator << (ostream& out, const entry& a);
    };

    class cursor
    {
        database* data_;
        size_t ind_;
        friend class entry;
        friend class database;

    public:
        cursor (database* a, size_t ind);
        cursor (const cursor& a);
        void operator= (const  entry x);
        void operator= (const cursor a);

        operator entry();           //type conversion
    };

and here is what I use in main():

    cout << data[4];

The short answer is "no". There are other threads describing why an implicit conversion of `data[4]` to an `entry` will not be performed in this case, although I don't have time right now to fine one and flag this question as a duplicate — Peter, Mar 17 '16 at 22:48
"MCVE" means that someone else can copy and paste your code and compile it without making any changes. — M.M, Mar 17 '16 at 23:19

score 6 · Accepted Answer · edited May 23 '17 at 10:28

When you write:

class entry
{
    // ...
    friend ostream& operator << (ostream& out, const entry& a);
};

Although this declares operator<< in the enclosing scope, the name lookup rules say that name lookup in that scope does not actually find this function! (Because it has only been declared via friend).

If a function has only been declared via friend, then the only way it can be found is via argument-dependent lookup. See this thread for more detailed explanation of the lookup rules.

The function would be found by:

entry e;
cout << e;

because ADL sees that there is an argument of type entry and so it searches functions that are associated with entry (including friends declared there).

However, cursor c; cout << c; does not include entry in its search list (even though a conversion from cursor to entry exists).

To fix this you need to provide a non-friend declaration of the operator, that is visible at the point of main. For example:

ostream& operator << (ostream& out, const class entry& a);

class entry
{
    // ...
    friend ostream& operator << (ostream& out, const entry& a);
};

NB. I chose to put the declaration before the class instead of after, because this is also the best way to solve the template friends problem.

Thank you! Haven't thought about that – tastelesscookie Mar 18 '16 at 16:16 — tastelesscookie, Mar 18 '16 at 16:16

Type conversion in ostream& operator <<

1 Answers1