Differentiate between overloading unary operator and overloading binary operator?

Answer 1

Unary operators declared as member function take NO arguments; if declared as global function, then take only one argument.

Binary operators declared as member functions take one argument; if declared as global function, then would take two arguments.

Note: The first argument for member function overloaded is always the class type; the class in which the operator is declared.

Answer 2

It is important to note that you cannot override operators with respect to primitive data types, nor can you define new operators. You can only override operators with respect to complex objects (non-primitives).

Unary operators, such as the prefix and postfix increment operators, and binary operators, such as the addition and subtraction operators, can be overloaded by declaring them members of a class. The l-value of all class operators is implicitly an instance of the class itself. The r-value (in the case of binary operators) can be any type, including primitives. The return value may be any type, but will typically be an instance of the l-value.

You cannot overload class operators for which you do not have access to the source. However, you can cater for this eventuality by using external functions which overload the operator itself. These operators require an l-value (an instance of the class for which you do not have access), and an r-value (an instance of the class for which an overload does not yet exist). Again, the return value will typically be an instance of the l-value. External operator overloads are often declared friends of the r-value class, however it is important to note that this is only necessary when a suitable interface does not exist within the r-value and the only solution is to allow the operator private access to the class members. Although friends are often said to undermine encapsulation this is errant nonsense. Nevertheless, friend access should be kept to an absolute minimum and should only be employed when there is no suitable interface. If exposing an interface would itself undermine encapsulation, then friend access would, in fact, re-enforce that encapsulation.

Answer 3

A picture paints a thousand words, so here's a code sample:

class MyClass {private:int value;

public:MyClass(int initValue) : value(initValue) {}

MyClass operator-() const {MyClass result(-value);return result;}

int getValue() const {return value;}};

Note that operator-() returns a new MyClass object; the original object is unmodified.