1. Department of Computer and Information Science, School of Science, IUPUI
Operator Overloading
Dale Roberts, Lecturer
Computer Science, IUPUI

2. Operator Overloading
Function-call notation is cumbersome for certain kinds of classes, especially mathematical classes
Allows extendable design
Most appropriate for math classes. eg. Matrix, Vector, etc.
Gives Operators Class-Specific Functionality
In-built or Standard Overloading for Basic Numerical Data Types -- + can be used with int, float, doubles
Analogous to Function Overloading -- is Used as the Function Name
40 Operators can be Overloaded to Give Class-Specific Functionality
C++ enables programmers to overload operators to be sensitive to the context in which they are used.  The compiler generates appropriate code
Easier to read

3. Requirements of Overloaded Operators
Their Meaning Should be Intuitive -- + Should Mean Addition
When Appropriate, they Should be Associative -- a + b Should Result in an Object, c of the Same Class
If these Conditions are Not Satisfied then it is Better to Use Member Functions and Not Operator Overloading
To use an operator on class objects, that operator must be overloaded - with two exceptions - the assignment operator (=), which performs a member wise copy, and the address (&) operator

4. Forms of Overloaded Operators
Member Functions
Friend Functions
Free-Standing or Global Functions

5. Operator Functions
When to make class members, friends or global functions?
If member function, then this is implicitly available for one of the arguments
When overloading ( ), [ ], ->, or =, the operator overloading function must be declared as a class member.  For other operators, the overloading functions can be non-members
When an operator function is implemented as a member function, the left most (or only in the case of unary operators) operand must be a class object (or a reference to a class object) of operator's class
If the left operand must be an object of a different class or a built-in type, this operator must be implemented as a non-class member. eg. <<, >> operators
An operator function implemented as a non-member must be a friend if it needs to access non-public data members of that class.
The overloaded << operator must have a left operand of type ostream.  Therefore, it must be a non-member function.  Also, it may require access to the private data members of the class.  Thus, it needs to be a friend function for that class.
Similar observation holds for >> operator which has a left operand of type istream.
Operator member functions are classed only when the left operand of a binary operator is specifically an object of that class or when the single operand of a unary operator is an object of that class.
If the operator needs to be commutative (a + b = b + a), then making it a non-member function is necessary.

6. Restrictions of Overloaded Operators
New Operators CANNOT be Created
Fundamental Data Types (e.g. int) CANNOT be Overloaded
Operator Priority CANNOT be Changed
Operator Associativity CANNOT be Changed
The arity of CANNOT be changed -- + can Take ONLY One or TWO Arguments
Two Separate Overloaded Functions (With Different Signatures) can be Created for Operators Which Exist in Pre-fix and Post-fix Form -- ++
Overloaded Operators are NOT IMPLICITLY Associative or Commutative, Even if the Original Operators were Associative or Commutative -- Associativity and Commutativity MUST be EXPLICITLY IMPLEMENTED
Overloading the operator + does not automatically overload related operators (+=, ++, etc).  If needed, these related operators must be explicitly overloaded

7. Unary Overloaded Operators -- Member Functions
Invocation in Two Ways -- (Direct) or (As a Function)
class number{
int n;
public:
number(int x = 0):n(x){};
number operator-(){return number (-n);} };
main() {
number a(1), b(2), c, d;
//Invocation of "-" Operator -- direct
d = -b; //d.n = -2
//Invocation of "-" Operator -- Function
c = a.operator-(); //c.n = -1 }

8. Binary Overloaded Operators -- Member Functions
Invocation in Two Ways -- ObjectB (direct) or (As a Function)
class number{
int n;
public:
number(int x = 0):n(x){};
number operator+(number ip)
{return number (ip.n + n);} };
main() {
number a(1), b(2), c, d;
//Invocation of "+" Operator -- direct
d = a + b; //d.n = 3
//Invocation of "+" Operator -- Function
c = d.operator+(b); //c.n = d.n + b.n = 5 }

9. Operator Overloading Using a Friend Function
Number of Parameters Accepted by an Overloaded Friend Operator Function Depend Upon the Operator Type -- One for Unary Operators and Two for Binary Operators
class complex{
int re, im;
public:
complex(int ip1 = 0, int ip2 = 0)
:re(ip1), im(ip2){}
friend complex operator+(complex, complex); };
//Friend Operator + Function
complex operator+(complex a, complex b)
{return complex(a.re+b.re, a.im+b.im);}
main(){
complex one(1,1), two(2,2), three;
three = operator+(one, two); //three = one + two }

10. Operator Functions as Class Members vs. as friend Functions
Non-member overloaded operator functions
Enable the operator to be commutative
HugeInteger bigInteger;
int integer;
bigInteger = integer + bigInteger; or
bigInteger = biginteger + integer;

11. Global Operator Overloading
Similar to friend Function Overloading, Except the Keyword friend is Omitted and Global Functions CANNOT ACCESS private Members
class complex{ //All Public Members!
public:
int re, im;
complex(int ip1 = 0, int ip2 = 0)
:re(ip1), im(ip2){} };
void operator!(complex a) {
int temp = a.re; a.re = a.im; a.im = temp;
cout << "Real: " << a.re << endl;
cout << "Imaginary: " << a.im << endl; }
main()
complex one(1,2);
operator!(one);

12. Overloading of Operators Having a Variable Arity
Operators Such as + and - Can be Unary or Binary
Overloading of Such Operators Involves Creating a Unary Function (One Operand) and a Binary Function (Two Operands)
Only if Both the Forms are Used, They Need to be Implemented
class number{
int n;
public:
number(int x = 0):n(x){}
number operator-(){n = -n; return *this;}
number operator-(number ip) {return(n-ip.n);} };
main(){
number one(1), two(2), three;
one = -one; //unary operator
three = one - two; //three.n = -3 }

13. Operators with Prefix and Postfix Forms
Separate Functions for Each -- Prefix and Postfix -- Forms are Needed
Prefix Form is Treated as an Unary Operator
Postfix Form is Treated as a Binary Operator

14. Prefix Overloaded Function -- Example
class number{
int n;
public:
number(int x):n(x){}; //Constructor
//prefix operator -- unary
number operator++(); };
number number::operator++(){
n++; return *this;}
main(){
number one(10); //one.n = 10
one++; //one.n = 11 }

15. Postfix Overloaded Function -- Example
Postfix Operator is Implemented as a Binary Operator with an int Argument with a Default Value of 0
class number{
int n;
public:
number(int x):n(x){}; //Constructor
//postfix operator -- binary -- int argument
number operator++(int); };
number number::operator++(int y)
{n += y; return *this;}
main() {
number one(10); //one.n = 10
one.operator++(2); //one.n = 12 }

16. Special Overloading Forms
A Few Operators Require Special Treatments During Overloading
Conversion Operator
const Array Operator
Function Call -- Parenthesis Operator
Stream Insertion -- << Operator
Stream Extraction -- >> Operator
Pointer to Member -- -> Operator
Assignment Operator
new Operator
delete Operator

17. Overloading Stream-Insertion and Stream-Extraction Operators
Overloaded << and >> operators
Must have left operand of types ostream &, istream & respectively
It must be a non-member function (left operand not an object of the class)
It must be a friend function if it accesses private data members

18. 1 // Fig. 18.3: fig18_03.cpp
2 // Overloading the stream-insertion and
3 // stream-extraction operators.
4 #include <iostream> 5
6 using std::cout;
7 using std::cin;
8 using std::endl;
9 using std::ostream;
10 using std::istream; 11
12 #include <iomanip> 13
14 using std::setw; 15
16 class PhoneNumber {
17 friend ostream &operator<<( ostream&, const PhoneNumber & );
18 friend istream &operator>>( istream&, PhoneNumber & ); 19
20 private:
21 char areaCode[ 4 ]; // 3-digit area code and null
22 char exchange[ 4 ]; // 3-digit exchange and null
23 char line[ 5 ]; // 4-digit line and null
24 }; 25
26 // Overloaded stream-insertion operator (cannot be
27 // a member function if we would like to invoke it with
28 // cout << somePhoneNumber;).
29 ostream &operator<<( ostream &output, const PhoneNumber &num )
30 {

19. 31 output << "(" << num.areaCode << ") "
<< num.exchange << "-" << num.line;
33 return output; // enables cout << a << b << c;
34 } 35
36 istream &operator>>( istream &input, PhoneNumber &num )
37 {
38 input.ignore(); // skip (
39 input >> setw( 4 ) >> num.areaCode; // input area code
40 input.ignore( 2 ); // skip ) and space
41 input >> setw( 4 ) >> num.exchange; // input exchange
42 input.ignore(); // skip dash (-)
43 input >> setw( 5 ) >> num.line; // input line
44 return input; // enables cin >> a >> b >> c;
45 } 46
47 int main()
48 {
49 PhoneNumber phone; // create object phone 50
51 cout << "Enter phone number in the form (123) :\n"; 52
53 // cin >> phone invokes operator>> function by
54 // issuing the call operator>>( cin, phone ).
55 cin >> phone; 56
57 // cout << phone invokes operator<< function by
58 // issuing the call operator<<( cout, phone ).
59 cout << "The phone number entered was: " << phone << endl;
60 return 0;
61 }

20. Enter phone number in the form (123) 456-7890:
(800)
The phone number entered was: (800)

21. Converting between Types
Cast operator
Convert objects into built-in types or other objects
Conversion operator must be a non-static member function.
Cannot be a friend function
Do not specify return type
For user-defined class A
A::operator char *() const; // A to char
A::operator int() const; //A to int
A::operator otherClass() const; //A to otherClass
When compiler sees (char *) s it calls
s.operator char*()

22. Converting between Types (cont)
The compiler can call these functions to create temporary objects.
If s is not of type char *
Calls A::operator char *() const; for
cout << s;

23. Special overloading forms - Example
Special Forms Example

24. Acknowledgements
These slides were originally development by Dr. Uday Murthy and Dr. Rajeev Raje.
Some contents comes from the Deitel slides that accompany your text.