Is a conversion constructor called for this overloaded operator? (C++)

Question

Given that this is the only == function in the class,

bool myClass::operator == ( const myClass & rhs )
{
    if ( var1 == rhs.var1 )
        return true;
    else
        return false;
}

What does the following comparison assume?

myClass mc1;
anotherClass ac1;

if ( mc1 == ac1 )

My instinct was to say that it assumes that ac1 will be converted to type myClass, but how can that happen? operator== has a parameter of type myClass & rhs, so how could myClass's conversion constructor be called when ac1 is passed to the function?

Thanks!

Conversion creates a temporary object. `const` references can bind to temporaries. If the operator were `bool myClass::operator==(myClass& rhs)` then conversion would not be possible. — Ben Voigt, Mar 20 '12 at 20:50
The C++ Standard forbids binding a non-`const` reference to a temporary variable (at least one major compiler ignores this rule, however). The reasoning is pretty simple: if the function writes its results through a non-`const` reference parameter, and that reference was bound to a temporary, they will be lost. — Ben Voigt, Mar 20 '12 at 21:17

score 3 · Answer 1 · answered Mar 20 '12 at 20:51

3

The parameter is of type const myClass & so a conversion call is called, a temporary is constructed and a const-reference to such a temporary is passed to the function. Upon return, the temporary is destroyed.

answered Mar 20 '12 at 20:51

rodrigo

94,151
12
143
190

score 1 · Answer 2 · answered Mar 20 '12 at 20:47

The compiler takes the left hand side and tries to find the right operator for it.

So it will take the == operator, and try to fit the right hand side to a myClass by casting.

If it can't find implicit casting to myClass it will return a compilation error.

Andrew Tomazos · Answer 3 · 2012-03-20T21:10:32.483

The compiler given mc1 == ac1 will search for the best match for the operator==(A,B) using the normal overload resolution rules for any function.

Assuming it finds your bool myClass::operator==(const myClass&) function the unambiguously best match (this may not be the case. for example it may find an operator declared bool operator==(const myClass&, const anotherClass&) which is superior instead), it will then bind and make the necessary parameter conversions as it would for any function call.

To make the conversion from an lvale of type anotherClass to a const myClass& (assuming anotherClass does not inherit from myClass, in which case no conversion would be needed) it will then search for a single (unambiguously best) converting constructor or conversion operator to turn the parameter into a myClass temporary and then execute the operator== call with that.

It the parameter of a function is a non-const reference than it will not consider performing such temporary conversion. The reason is that a non-const reference usually indicates that the function will perform some sideeffect on that parameter, which would be discarded when the temporary is destroyed leaving the original object uneffected - therefore it would most likely be a logic error accidently discarding this sideeffect than intentionally doing so - so the language designers disallowed it.

Matteo Italia · Accepted Answer · 2012-03-20T20:55:09.560

1

Since there's no perfect overload for that operator the converting constructor is called (it counts as an implicit conversion), and the temporary created in this way is passed to your operator==. After the call the temporary is destroyed.

Notice that this wouldn't happen if operator== accepted a non-const reference, because temporaries can be bound only to const references.

edited Mar 20 '12 at 20:55

answered Mar 20 '12 at 20:49

Matteo Italia

123,740
17
206
299

Thanks for the answer, but why is that? (that temporaries can only be found to const references) – JamesGold Mar 20 '12 at 20:55
1

@JamesGold: it's not really a technical problem, but more a "safety net"; see [this question](http://stackoverflow.com/questions/1565600/how-come-a-non-const-reference-cannot-bind-to-a-temporary-object). – Matteo Italia Mar 20 '12 at 21:01

score 0 · Answer 5 · answered Mar 20 '12 at 20:47

0

Your assumption is correct. The compiler will put it the conversion constructor call first, then call your == method with the converted object as the rhs argument.

answered Mar 20 '12 at 20:47

Becuzz

6,846
26
39

score 0 · Answer 6 · answered Mar 20 '12 at 21:09

0

There are two other possible answers to your riddle, neither involving conversation constructors.

There exists a free function, bool operator==(const myClass&, const &anotherClass);, or
anotherClass is publicly derived from myClass.

answered Mar 20 '12 at 21:09

Robᵩ

163,533
20
239
308

Is a conversion constructor called for this overloaded operator? (C++)

6 Answers6