🚀 go-pugleaf

chopps@water.emich.edu (Christian E. Hopps) wrote:
>When figuring out which operator to use is any precedence given to
>operators defined in the class? 

struct A { A(int); operator int(); bool operator== (      A&); };
struct B { B(int); operator int(); bool operator== (const B&); };
struct C { C(int); operator int(); };
bool operator==(const C&, const C&);
 
void f()
{
  A a(0);
  a == 3;  // OK, int(a) == 3  [!!]
  3 == a;  // OK, 3 == int(a) 
  B b(0);
  b == 3;  // error: b == B(3), or int(b) == 3 ?
  3 == b;  // OK, 3 == int(b)
  C c(0);
  c == 3;  // error: c == C(3), or 3 == int(c) ?
  3 == c;  // error: 3 == int(c), or C(3) == c ?
}

I believe the remarks above are correct.  (Notice [!!] that leaving 
out the "const" in A means that conversion isn't attempted, because the 
result of an implicit conversion is const.)

This really argues for avoiding conversion loops, so you don't
have to remember the silly rules; and if you must use a type that
has such a loop, explicitly qualify the arguments so you get the
operation you want.

Nathan Myers
myersn@roguewave.com


[ 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. ]