🚀 go-pugleaf

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.

Suppose first you overload operator+, then you overload operator. in MyClass:

class MyClass {
private:
   AnnotherClass* theOtherClass;
public:
   AnnotherClass operator. ();
   MyClass       operator+ (int);
   void          Something_only_defined_in_MyClass ();
};

MyClass A;

A + 2; is equivalent with A.operator (2) and (A.operator.).operator (2)

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):
(&A)->a_member is equivalent with ((A.operator.).operator&)->a_member.

How can yu access Something_only_defined_in_MyClass ?

If operator. return theOtherClass, why don't you just write:
AnnotherClass*	theOtherClass;

theOtherClass + 2;

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

Valentin Bonnard
bonnardv@pratique.fr
---
[ 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. ]