difference between global operator and member operator

Question

Is there a difference between defining a global operator that takes two references for a class and defining a member operator that takes only the right operand?

Global:

class X { public:     int value; };  bool operator==(X& left, X& right)  {     return left.value == right.value; }; 

Member:

class X {     int value;     bool operator==( X& right)      {         return value == right.value;     }; } 

Answer 1

One reason to use non-member operators (typically declared as friends) is because the left-hand side is the one that does the operation. Obj::operator+ is fine for:

obj + 2 

but for:

2 + obj 

it won't work. For this, you need something like:

class Obj {     friend Obj operator+(const Obj& lhs, int i);     friend Obj operator+(int i, const Obj& rhs); };  Obj operator+(const Obj& lhs, int i) { ... } Obj operator+(int i, const Obj& rhs) { ... } 

Answer 2

Your smartest option is to make it a friend function.

As JaredPar mentions, the global implementation cannot access protected and private class members, but there's a problem with the member function too.

C++ will allow implicit conversions of function parameters, but not an implicit conversion of this.

If types exist that can be converted to your X class:

class Y { public:     operator X();  // Y objects may be converted to X };   X x1, x2; Y y1, y2; 

Only some of the following expressions will compile with a member function.

x1 == x2;   // Compiles with both implementations x1 == y1;   // Compiles with both implementations y1 == x1;   // ERROR!  Member function can't convert this to type X y1 == y2;   // ERROR!  Member function can't convert this to type X 

The solution, to get the best of both worlds, is to implement this as a friend:

class X {     int value;  public:      friend bool operator==( X& left, X& right )      {         return left.value == right.value;     }; };