Re: Is it possible to override raw pointer comparison?
* blargg:
Ian Collins wrote:
Ash wrote:
On May 24, 6:48 am, Neelesh <neelesh.bo...@gmail.com> wrote:
On May 24, 8:26 am, Ash <ashiru...@googlemail.com> wrote:
Why is this ok:
bool operator==(Foo* a, Foo& b) { return true; }
and if I have:
Foo* f1; Foo* f2;
then
f1 == *f2
is valid and calls the above function.
but the following (to try to override equality when called using two
raw pointers: f1 == f2):
bool operator==(const Foo* a, const Foo* b) { return true; }
doesn't compile?
[...]
operator overloading is
allowed only when atleast one operand is a user defined type (either a
class or an enumeration type).
[...]
I suspected as much, but in which case I don't udnerstand why the
first case:
bool operator==(Foo* a, Foo& b) { return true; }
is ok? Where's the logic of the C++ standards body in allowing this,
which is an operation on a pointer and not when both operands are?
Foo& is a user defined type.
(to elaborate further) and operator == has no built-in meaning for
user-defined types, thus you can provide one.
Ah, well, we have a terminology problem. Or rather, the standard has one. I
don't feel like listing and discussing here all the umpteen nowhere-defined
terms that the standard uses for various groups of types, but suffice it to say
that it's an inconsistent mess.
However, even though "user-defined type" is pretty unclear, note that an
enumeration type has a built-in meaning for ==.
I think we need a term such as "customizable type", which then is an enumeration
or class type. And that we need to be clear that "built-in type" doesn't mean
whatever (very unclear) it means in the standard. But means an actual built-in
type! <g>
Then such issues can be discussed.
I think I'll start adopting that terminology.
Cheers, & hth.,
- Alf
--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!