Confused about operator overloading warning message

I know its a mistake to declare the second parameter here as a const, but I don't understand the error message:

Code:

---

istream& operator>>(istream& is, const X& x)
{
    is >> x.ch;
    return is;
}

warning C4717: 'operator>>' : recursive on all control paths, function will cause runtime stack overflow

---

Presumably the function call >> x.ch either calls this function again, or is defined in terms of this function, etc.

Quote:

---

Originally Posted by tabstop

Presumably the function call >> x.ch either calls this function again, or is defined in terms of this function, etc.

---

I still don't understand, because the only reason for the warning message is the const. If I remove it, there's no warning.

OK. It looks like I posted this in the C# forum instead of the C++ forum :rolleyes:

It's off to the opticians for me.

Moved to C++ Programming forum.

Quote:

---

Originally Posted by Sharke

I still don't understand, because the only reason for the warning message is the const. If I remove it, there's no warning.

---

The const is logically wrong, but I am not sure what to make of the warning either. I suggest that you post the smallest and simplest program that demonstrates the warning message.

OK this should do it:

Code:

---

#include <iostream>
using namespace std;

class X
{
    char ch;
public:
    X(char chch): ch(chch) {}
    friend ostream& operator<<(ostream& os, const X& x)
    {
        return os << x.ch;
    }
    friend istream& operator>>(istream& is, const X& x);
};


istream& operator>>(istream& is, const X& x)
    {
        return is >> x.ch;
    }

int main() {}

---

I'm only given the warning message (VC++ Express) if the operator>> friend function is defined outside of the class body and if the second parameter is declared as const. If I take the const out, no warning message. However, if I define the function inside the body of the class like I have with operator<<, I'm given no warning even with the const. Warnings are set at level 4.

Oh, I think I know why: there is an implicit conversion from char to X, thus the expression is >> x.ch causes a temporary X to be constructed, and then this temporary is then used as an argument to operator>>, hence causing infinite recursion.

If you had declared the constructor as explicit, then problem would have surfaced in a different way. In fact, the MinGW port of g++ 3.4.5 does not warn that infinite recursion can happen with the -Wall option.

Quote:

---

Originally Posted by laserlight

Oh, I think I know why: there is an implicit conversion from char to X, thus the expression is >> x.ch causes a temporary X to be constructed..

---

Why the conversion from char to X? And why the different behavior when the function is defined outside of the class body?

Quote:

---

Originally Posted by Sharke

Why the conversion from char to X?

---

Because you have a constructor that takes a char. Consider:

Code:

---

class X
{
    char ch;
public:
    X(char chch): ch(chch) {}
};

void foo(const X& x)
{
}

int main()
{
    foo('a');
}

---

Quote:

---

Originally Posted by Sharke

And why the different behavior when the function is defined outside of the class body?

---

Maybe MSVC's static analysis only detected the infinite recursion when the non-member function was defined outside of the class definition.

>> Why the conversion from char to X?

X is const and so X.ch is as well. Since there isn't a corresponding istream::operator >> for const char& (obviously) the compiler chooses the next best thing, ie: to invoke the constructor of temporary of type X.

>> And why the different behavior when the function is defined outside of the class body?

Compiler peculiarity.

I think I see! Thanks guys. That's another small piece of icing on my C++ cake. If I stop the constructor from taking a char (or make it explicit) then no conversion takes place and I get an appropriate error message about >> not taking a right hand operand of const char.

>> If I stop the constructor from taking a char then no conversion takes place and I get an appropriate error message about >> not taking a right hand operand of const char.

Another option is to disallow implicit conversion by declaring the constructor like so:

Code:

---

explicit X(char chch): ch(chch) {}

---

Quote:

---

Originally Posted by Sebastiani

>> If I stop the constructor from taking a char then no conversion takes place and I get an appropriate error message about >> not taking a right hand operand of const char.

Another option is to disallow implicit conversion by declaring the constructor like so:

Code:

---

explicit X(char chch): ch(chch) {}

---

---

Beat you to it by one minute in the edit! :)

At least I finally understand what explicit is for....I'd kind of skimmed over the explanation in my book because my mind wasn't in the right place.