Re: Error operator+ function
On Feb 12, 7:04 pm, Ian Collins <ian-n...@hotmail.com> wrote:
On 02/13/11 12:10 AM, James Kanze wrote:
[...]
You have to remove the ambiguity. For starters, making the constructor
from unsigned explicit removes one possible accidental conversion. Then
you can remove the operator + for unsigned. That leaves only one
possible sequence of conversions.
But likely not the one he wants.
How do you know? Considering he doesn't even test the result! In this
example, it doesn't matter whether operator+(unsigned, int) or
A::operator+(const A&) is called.
Just guessing, but in general, if you define an operator+ for a
class, you want it to be used when adding values of that class.
You could also remove the remaining operator + and use a free function:
A operator+( const A& a, const A& b )
{
A t(a);
t += b;
return t;
}
(For the expression d + 7, where d has type A, and type A has
both a constructor taking unsigned, and a conversion operator to
unsigned.)
How would that remove the ambiguity? You'd still have the two
possibilities: convert the A to unsigned, and use integer
arithmetic, or convert the int to A, and use the above. The
first results in a better match for the first argument, and the
second a better match for the second, so the expression is
ambiguous.
Not if the constructor from unsigned is explicit.
If the constructor from unsigned is explicit, then the
expression is unambiguous, regardless of whether the operator is
a member or not; there is only one operator+ which can be
called, and that is the built-in one. The reason for preferring
a non-member is so that 7 + d has the same behavior at the
interface level as d + 7. If d + 7 is legal, and 7 + d isn't,
then you're clearly abusing operator overloading.
--
James Kanze