1. http://cs.mst.edu Overloading Operators

2. http://cs.mst.edu Operators  Operators are functions, but with a different kind of name – a symbol.  Functions have parameters to which you pass arguments; operators have parameters to which you pass operands. Operands = Arguments.  The name of a operator is “operator ”  Operators are called differently from functions.

3. http://cs.mst.edu Operators  Operators are functions, but with a different kind of name – a symbol.  Functions have parameters to which you pass arguments; operators have parameters to which you pass operands. Operands = Arguments.  The name of a operator is “operator ”  Operators are called differently from functions.  We say “operator overloading” because all operators are already defined – you cannot create new operators.

4. http://cs.mst.edu Operators  Operators are functions, but with a different kind of name – a symbol.  Functions have parameters to which you pass arguments; operators have parameters to which you pass operands. Operands = Arguments.  The name of a operator is “operator ”  Operators are called differently from functions.  We say “operator overloading” because all operators are already defined – you cannot create new operators.  An operator can be defined either as a member function of a class or a non-member function.

5. http://cs.mst.edu Operator Calls  Example: var1 * var2 (a binary operator)

6. http://cs.mst.edu Operator Calls  Example: var1 * var2 (a binary operator)  var1 is the lhs operand, var2 is the rhs operand.  If operator * () is a non-member function, then var1 and var2 are arguments passed to fill two parameters.  If operator * () is a member function, then var1 is the calling object and var2 is passed to a parameter

7. http://cs.mst.edu Operator Calls  Example: ~var1 (a unary operator)  var1 is the only operand.  If operator ~ () is a non-member function, then var1 is the argument passed to fill a single parameter.  If operator ~ () is a member function, then var1 is the calling object.

8. http://cs.mst.edu Operators  insertion and extraction: >> and <<  cout << var;  cin >> var;

9. http://cs.mst.edu Operators  insertion and extraction: >> and <<  arithmetic: +, -, *, and /  var1 + var2  var1 - var2  var1 * var2  var1 / var2

10. http://cs.mst.edu Operators  insertion and extraction: >> and <<  arithmetic: +, -, *, and /  assignments: =  var1 = var2;  var1 = var2 + var3;

11. http://cs.mst.edu Operators  insertion and extraction: >> and <<  arithmetic: +, -, *, and /  assignments: =  arithmetic assignments: +=, -=, *=, and /=  var1 += var2;  var1 -= var2;  var1 *= var2;  var1 /= var2;

12. http://cs.mst.edu Operators  insertion and extraction: >> and <<  arithmetic: +, -, *, and /  assignments: =  arithmetic assignments: +=, -=, *=, and /=  brackets and parenthesis: [] and ()  object[index_pos] = var;  object(var);

13. http://cs.mst.edu Operators  insertion and extraction: >> and <<  arithmetic: +, -, *, and /  assignments: =  arithmetic assignments: +=, -=, *=, and /=  brackets and parenthesis: [] and ()  and many others!

14. http://cs.mst.edu Operators  insertion and extraction: >> and <<  arithmetic: +, -, *, and /  assignments: =  arithmetic assignments: +=, -=, *=, and /=  brackets and parenthesis: [] and ()  and many others!  FORBIDDEN OVERLOADS: ::..* sizeof ?:

15. http://cs.mst.edu Additional Rules  You cannot create new operators.

16. http://cs.mst.edu Additional Rules  You cannot create new operators.  If you overload an operator, at least one of the parameters must be a user-defined type.

17. http://cs.mst.edu Additional Rules  You cannot create new operators.  If you overload an operator, at least one of the parameters must be a user-defined type.  You cannot change the arity of a operator.

18. http://cs.mst.edu Additional Rules  You cannot create new operators.  If you overload an operator, at least one of the parameters must be a user-defined type.  You cannot change the arity of a operator.  You cannot change the order of precedence of operators by overloading them.

19. http://cs.mst.edu Additional Rules  You cannot create new operators.  If you overload an operator, at least one of the parameters must be a user-defined type.  You cannot change the arity of a operator.  You cannot change the order of precedence of operators by overloading them.  Certain operators must be overloaded as class members. They are = [] () ->

20. http://cs.mst.edu Additional Rules  You cannot create new operators.  If you overload an operator, at least one of the parameters must be a user-defined type.  You cannot change the arity of a operator.  You cannot change the order of precedence of operators by overloading them.  Certain operators must be overloaded as class members. They are = [] () ->  An overloaded operator cannot have default arguments.

21. http://cs.mst.edu Rules of Thumb  Make your definitions of an overloaded operator make sense. As an example, you would not want to define ‘+’ for complex numbers as subtraction.

22. http://cs.mst.edu Rules of Thumb  Make your definitions of an overloaded operator make sense. As an example, you would not want to define ‘+’ for complex numbers as subtraction.  Define an operator overload as a member function if it modifies the calling object; as a nonmember function if it doesn’t.

23. http://cs.mst.edu Rules of Thumb  Make your definitions of an overloaded operator make sense. As an example, you would not want to define ‘+’ for complex numbers as subtraction.  Define an operator overload as a member function if it modifies the calling object; as a nonmember function if it doesn’t.  Define symmetric operator pairs in terms of one another. As an example, define != using the == operator you already defined.

24. http://cs.mst.edu Recall //fraction.cpp... Fraction mult_fracs(const Fraction & lhs, const Fraction & rhs) { Fraction temp; temp.m_Numerator = lhs.m_Numerator * rhs.m_Numerator; temp.m_Denominator = lhs.m_Denominator * rhs.m_Denominator; return temp; } //fraction.h... class Fraction {... friend Fraction mult_fracs(const Fraction & lhs, const Fraction & rhs);... };

25. http://cs.mst.edu Revised! //fraction.cpp... Fraction operator* (const Fraction & lhs, const Fraction & rhs) { Fraction result(lhs); return (result*=rhs); } //fraction.h... class Fraction {... friend Fraction operator* (const Fraction & lhs, const Fraction & rhs);... };

26. http://cs.mst.edu Revised! //fraction.cpp... Fraction operator* (const Fraction & lhs, const Fraction & rhs) { Fraction result(lhs); return (result*=rhs); } //fraction.h... class Fraction {... friend Fraction operator* (const Fraction & lhs, const Fraction & rhs);... }; needs to be defined

27. http://cs.mst.edu Revised! //fraction.cpp... Fraction& Fraction::operator*= (const Fraction & rhs) { m_Numerator*=rhs.m_Numerator; m_Denominator*=rhs.m_Denominator; return (*this); } //fraction.h... class Fraction {... friend Fraction operator* (const Fraction & lhs, const Fraction & rhs); Fraction& operator*= (const Fraction & rhs);... };

28. http://cs.mst.edu *this x 5 int pointer int

29. http://cs.mst.edu *this x 5 int pointer int x refers to the pointer

30. http://cs.mst.edu *this x 5 int pointer int *x refers to the int being pointed at

31. http://cs.mst.edu *this this Fraction& Fraction::operator*= (const Fraction & rhs) { m_Numerator*=rhs.m_Numerator; m_Denominator*=rhs.m_Denominator; return (*this); } Fraction pointer Fraction this refers to the pointer that is keeping track of your Fraction object’s place in memory – pointing to the calling object of this function

32. http://cs.mst.edu *this this Fraction& Fraction::operator*= (const Fraction & rhs) { m_Numerator*=rhs.m_Numerator; m_Denominator*=rhs.m_Denominator; return (*this); } Fraction pointer Fraction *this refers to the fraction object currently executing your call to *= the calling object

33. http://cs.mst.edu End of Session