操作符重载( From C++ prime)

To overload an operator, you use a special function form called an operator function. An operator function has the form

operator op(argument-list)

where op is the symbol for the operator being overloaded. E.g, operator+() overloads the +operator and 

operator*() overloads the *operator.

Member and nonmember function:

Typically, the nonmember version is a friend function so that it can directly access the private data for a class. For example, consider the addition operator for the Time class. It has this prototype in the Time class declaration:
Time operator+(const Time & t) const; // member version
Instead, the class could use the following prototype:
friend Time operator+(const Time & t1, const Time & t2); // nonmember version
The addition operator requires two operands. For the member function version, one is passed implicitly via the  this pointer and the second is passed explicitly as a function argument. For the friend version, both are passed as arguments.

The compiler can convert the statement
T1 = T2 + T3; to either of the following:
T1 = T2.operator+(T3); // member function
T1 = operator+(T2, T3); // nonmember function

In a word, A nonmember version of an overloaded operator function requires as many formal parameters as
the operator has operands. A member version of the same operator requires one fewer parameter because one operand is passed implicitly as the invoking object.

 For some operators, as mentioned earlier, the member function is the only choice.
function is the only valid choice. Otherwise, it often doesn’t make much difference.