The first thing is that there is no advantage in implementing the operator as a member function, and there can be advantages in doing it as a free function. In particular, a member function is not symmetric with respect to the types of the two operands, the left-hand-side (lhs) must be of the exact type of the class on which it is being called, while the right-hand-side (rhs) can use implicit conversions. In the case of free function operators, the same conversions can be applied to lhs and rhs.
struct SomeClass {
SomeClass( int value );
bool operator<( SomeClass const & ) const;
};
bool operator>( SomeClass const &, SomeClass const & );
int main() {
SomeClass x( 10 );
x < 100; // Fine, lhs is SomeClass
// 100 < x; // Error, no operator< can take int as lhs and SomeClass
x > 100; // Fine
100 > x; // Also fine, lhs can take the same implicit conversions
}
Note that the main difference here are the implicit conversions, and that makes a difference only if your type can be implicitly converted from other types. If there are no implicit conversions into your type, then this point would be moot, but considering that there is no disadvantage in using a free function and there are advantages in some cases, I would use free functions whenever possible.
I wrote some time ago about operator overloading here, you might find some suggestions there.