Operator Overloading: Issues and Guidelines

• The compiler defines assignment and "address of" (operator&) operators, all others must be defined by the class
• Try to map operators to analogous operations
• If the operator's operation is ambiguous to the user, then it should be a named member function of the class
• The comparison logical operators (>, < >=;, <=, ==, !=) and the logical not operator (!), should return an int type, or a type that can be converted to int. This allows them to be used in places such as if statements
• All assignment type operators (=, +=, -=, *=, /=, %=, ^=, &=, |= >>=, <<=) and the subscript operator ([]) should usually return a reference. This allows their use in chained expressions
• The other basic operators (+, -, *, /, %, ^, &, |, ~, ++, --) should usually return temporary objects that will be automatically created in the local scope (on the stack)
• Assignment operators should check for self assignment
• Operators can be defined either as member functions, or as non-member global functions
• The main advantage of defining operators as member functions is increased encapsulation. In such cases, the overloaded operator receives one implicit argument (the this object). In the case of binary operators, the implicit argument is the object on the left hand side of the operator
• The main advantage of defining operators as non-member global functions is that the compiler performs implicit conversions on the first argument. For example:
  

  class Date{
  public:
  	Date(int d=30, m=1, y=1997) day(d), mon(m), year(y) {}
  	Date operator+(Date& );
  	friend Date operator+(Date& , Date& );
  	// Other public members go here
  private:
  	day, mon, year;
  };
  
  int main(){
  	Date d1, d2;
  	d1 = 30 + d2;		// Will work for global version only
  	d1 = Date(30) + d2;	// Will work for either version
  	d1 = d2 + 30; 		// Will work for either version
  
  	return 0;
  }