🚀 go-pugleaf

Valentin Bonnard <bonnardv@pratique.fr> writes:

>First of all, I suppose there is no difference bewten A + B, A.operator+ (B)
>and A.plus (B) when operator+ is defined as plus.

No, not in the semantics which Jim Adcock proposed and which I implemented.
The rule is very simple: you invoke the `operator . ()' function, if any,
if and only if the source code contains a `.'.  So `A.operator+(B)' and
`A.plus(B)' will invoke `operator . ()', but `A + B' will not.

>Suppose first you overload operator+, then you overload operator. in MyClass:
[...]
>MyClass A;
>
>A + 2; is equivalent with A.operator (2) and (A.operator.).operator (2)

Nope, according to Jim Adcock's proposal, `A + 2' would not invoke the
user-defined `operator . ()' function.  See above.

>You can't even write (&A)->Something_only_defined_in_MyClass () in order to
>access Something_only_defined_in_MyClass (which is only defined for MyClass):

Nope, according to Jim Adcock's proposal, for your example you are free to
do so.

>Note that A.m _is equivalent_ (provided that operator. is not overloaded in 
>AnnotherClass) with (&A)->m.

Nope, according to Jim Adcock's proposal that is not necessarily true either.
This is just like `x++' not necessarily being equivalent to `x = x + 1'
if you have overloaded `operator ++'.

With Jim Adcock's proposal, if you overload `operator .', you can make
the equivalence hold, by also overloading `operator &' to return a
smart pointer class.  Without his proposal, if you overload `operator &',
in the general case there is no way to make the equivalence hold.

--
Fergus Henderson             	WWW: http://www.cs.mu.oz.au/~fjh
fjh@cs.mu.oz.au              	PGP: finger fjh@128.250.37.3
---
[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]