Computer Programming

Lecture No. 12
Operator Overloading
 Introduction
• The variables of native data types can perform a
number of different operations (functions) using
operators ( +, - , / , *)
– Example: a + b * c
– Example: if ( a < b )

• However, with user defined (classes) objects we

can not use operators
– Example: class obj1, obj2;
if ( ob1 < obj2 )
 Introduction

• We want user-defined types to behave like

native data types

class complex { /* … */ };
complex a(2,1), b(3,0);
…
cout << a + b << a*b << -b;
cout << (a != b);
 Introduction
• With the help of operator overloading
we can add operator functionality in the
class’s objects

• However, before using any kind of

operator we need to implement its
functionality in the class
 Operator Overloading

• In order to add operator functionality in the

class

• First create a function for the class

• Set the name of the function with the
operator name
– operator+ for the addition operator ‘+’
– operator> for the comparison operator ‘>’
 Operator Overloading
• Operators are really functions
– They have arguments, they return values
– The only difference is that their names take on a
specific form:
• Operator+, operator[]

• Overloading provides concise notation

– object2 = object1.add(object2); // without operator
overloading
– object2 = object2 + object1; // with operator
overloading
 Restriction on Operator Overloading
• With operator overloading we cannot change
1. How operators act on built-in data types
• i.e., cannot change integer addition
2. Precedence of operator (order of evaluation)
• Use parentheses to force order-of-operations
3. Associativity (left-to-right or right-to-left)
4. Number of operands
• & is unitary, only acts on one operand

• Cannot create new operators

• Operators must be overloaded explicitly
– Overloading + does not overload +=
 Restriction on Operator Overloading

Operators that can be overloaded

+ - * / % ^ & |
~ ! = < > += -= *=
/= %= ^= &= |= << >> >>=
<<= == != <= >= && || ++
-- ->* , -> [] () new delete
new[] delete[]

Operators that cannot be overloaded

. .* :: ?: sizeof
 Function Overloading

• An overloaded function is one which has the

same name but several different forms.

• For example, we overloaded the constructor

for the Date class
– default Date d;
– initializing Date d(9,22,99);
– copy Date d1(d);
– other Date d(“Sept”,22,1999);
 Operator Overloading

• Just as there may be many versions of a function

due to overloading, there may be many versions of
operators.

• Example: operator/
– a = 14.0 / 2; (one float and one int argument)
– a = 14.0 / 2.0; (two float arguments)
– a = 14 / 2; (two ints, INTEGER DIVISION)

• Many operators are already overloaded for us to

handle a variety of argument types.
 Operator Overloading

• The operator “+” also has different

semantics depending on the type of its
“arguments”

• Example
int i, j;
double d, e;
i + j; /* add two int */
i + d; /* add an int and a double */
 Operator Overloading Syntax
• a = b + c;
• datatype operator+ (datatype)

Second parameter (can be native data type

or user defined data type)

Remember operator+ is a function, and it will be call

with the help of any object, thus the first parameter
is the calling object

return parameter (can be native data

type or user defined data type)
 Operator Overloading Syntax
datatype operator+ (datatype)
Example (1):
class myClass
{ int operator+ ( int ); }
int main ( )
{
int a, b;
myClass object;
a = object + b;
}
 Operator Overloading Syntax
datatype operator+ (datatype)
Example (2):
class myClass
{ int operator+ ( myClass &a ); }
int main ( )
{
int a;
myClass object1, object2;
a = object1 + object2;
}
 Operator Overloading Syntax
datatype operator+ (datatype)
Example (3):
class myClass
{ myClass operator+ ( int ); }
int main ( )
{
int a = 5;
myClass object1, object2;
object2 = object1 + a;
}
 Operator Overloading Syntax
• datatype operator+ (datatype)
• Example (4):
class myClass
{ myClass operator+ ( myClass &a ); }
int main ( )
{
myClass object1, object2, object3;
object3 = object1 + object2;
}
 Implementing Overloaded Operators

• The compiler uses the types of arguments

to choose the appropriate overloading.

int v1, v2; v1 + v2; // int +

float s1, s2; s1 + s2; // float+
 Extended Example

Employee class and objects

class Employee
{
private:
int idNum;
double salary;
public:
Employee(int id, double salary);
double addTwo (Employee& emp);
double operator+ (Employee& emp);
double getSalary() { return salary; }
}
 The member functions ‘addTwo’ and operator+
double Employee::addTwo(Employee& emp)
{
double total;
total = salary + emp.getSalary();
return(total);
}

double Employee::operator+(Employee& emp)

{
double total;
total = salary + emp.getSalary();
return(total);
 Using the Member Functions

double sum;
Employee Clerk (111, 10000), Driver (222, 6000);

// these three statements do the same thing

sum = Clerk.addTwo(Driver);

sum = Clerk.operator+(Driver);

sum = Clerk + Driver;

// the syntax for the last one is the most natural
// and is easy to remember because it is consistent
// with how the + operator works for everything else
 Multiple Operators

• Often, you may need to reference an

operator more than once in a expression.
• Example:
– total = a + b + c;
• But this can cause big problems when
operator overloading is involved
• See next few slides for an example
 Client Code for Class Employee

void main()
{
Employee Clerk(115, 20000.00);
Employee Driver(256, 15500.55);
Employee Secretary(567, 34200.00);
double sum;

sum = Clerk + Driver + Secretary;

cout << “Sum is “ << sum;

}
 The Problem

• Operator + is left to right associative, so

Clerk and Driver are added. The result is a
double.

• Now that double is on the left and an

Employee is on the right (Secretary)

• BUT THE OPERATOR + is only defined for

arguments of type Employee, not for
double
 The Problem Gets Worse

• It would seem that all we have to do is write

another version of the overloaded operator
to work with the argument (double)
• But…
– although we could overload an operator to work like
this:
– sum = Secretary + num;
• We cannot overload one like this:
– sum = num + Secretary; // why not?
 The Answer

• We cannot overload + for a double

• Double is a native type

• The real solution is to make sure that your

operator+ function never returns a double
(or any other native type).

• An operator to add Employees should

return an Employee (see next slide)
 Extended Example

Employee class and objects

class Employee
{
private:
int idNum;
double salary;
public:
Employee(int id, double salary);
Employee operator+ (Employee&
emp);
double getSalary() { return salary; }
}
 Solution Example

Employee Employee::operator+(Employee& emp)

{
Employee total(999,0); // dummy values
total.salary = salary + emp.salary;
return(total);
}
 Client Code for Class Employee

void main()
{
Employee Clerk(115, 20000.00);
Employee Driver(256, 15500.55);
Employee Secretary(567, 34200.00);
Employee sum(0, 0.0);

sum = Clerk + Driver + Secretary;

}
 29

Reading References

Robert Lafore: Chapter 8, Operator Overloading Page 319