1. Polymorphism
Objectives
In this lesson, you will learn to:
Define polymorphism
Overload functions
Identify overloading functions as an implementation of
static polymorphism
Understand the need for overloading operators
Overload the following unary operators:
Simple prefix unary operators
Pre and post increment and decrement operators
Overload a binary operator
©NIIT OOPS/Lesson 8/Slide 1 of 27

2. Polymorphism
Static Polymorphism
Refers to an entity existing in different physical forms
simultaneously
©NIIT OOPS/Lesson 8/Slide 2 of 27

3. Polymorphism
Function Overloading
Is the process of using the same name for two or
more functions
Requires each redefinition of a function to use a
different function signature that is:
different types of parameters,
or sequence of parameters,
or number of parameters
Is used so that a programmer does not have to
remember multiple function names
©NIIT OOPS/Lesson 8/Slide 3 of 27

4. Polymorphism
Constructor Overloading
Is commonly used in C++
Example:
#include iostream
class Calculator
{
int number1, number2, tot;
public:
Calculator();//Default Constructor
Calculator(int,int);//Two-Argument
//Constructor
};
©NIIT OOPS/Lesson 8/Slide 4 of 27

5. Polymorphism
Problem Statement 6.D.1
In an editor application such as the Microsoft Word, there
are several functions that perform various tasks, for
example, reading, editing, and formatting text, checking
for grammar, searching and replacing text, opening and
saving a file, and closing the application.
The description of a set of functions that perform the task
of opening a file is given below:
1. Opens the file on the basis of the file name specified
by the user
2. Opens the file on the basis of the file name and
directory path specified by the user
©NIIT OOPS/Lesson 8/Slide 5 of 27

6. Polymorphism
Problem Statement 6.D.1 (Contd.)
3. Opens the file on the basis of the file name, the
directory path, and the file format like the specified by
the user
Choose appropriate function names.
©NIIT OOPS/Lesson 8/Slide 6 of 27

7. Polymorphism
Problem Statement 6.P.1
State which of the following sets of functions are
overloaded:
1. void add(int, int);
void add(float, float);
2. void display(int, char);
int display(int, char);
3. int get(int);
int get(int, int);
4. int square(int);
float square(float);
©NIIT OOPS/Lesson 8/Slide 7 of 27

8. Polymorphism
Problem Statement 6.P.2
Identify functions that you are required to code for the
existing employee class to implement the following
requirements:
1. Display all employee records
2. Display an employee detail based on employee code
3. Display employee names based on department name
©NIIT OOPS/Lesson 8/Slide 8 of 27

9. Polymorphism
Need for Operator Overloading
To make operations on a user-defined data type as
simple as the operations on a built-in data type
©NIIT OOPS/Lesson 8/Slide 9 of 27

10. Polymorphism
Classification of Operators
Unary operators
Simple prefix unary operators
Pre and post increment and decrement operators
Binary operators
Simple operators
Comparison operators
The assignment operator
The insertion and extraction operator
Special operators
©NIIT OOPS/Lesson 8/Slide 10 of 27

11. Polymorphism
Simple Prefix Unary Operators
Are defined by either a member function that takes no
parameter or a non-member function that takes one
parameter
Example:
i1.operator -()
or
operator -(i1)
©NIIT OOPS/Lesson 8/Slide 11 of 27

12. Polymorphism
Overloading Simple Prefix Unary Operators
Example:
#include iostream
class MyInt
{
private :
int a;int b;
public :
void operator -(); // member function
void accept(int, int);
void print();
};
void MyInt ::operator –()
{
a=-a;b=-b;
}
©NIIT OOPS/Lesson 8/Slide 12 of 27

13. Polymorphism
Overloading Simple Prefix Unary Operators
(Contd.)
void MyInt ::accept(int x, int y)
{
a=x;b=y;
}
void MyInt ::print()
{
couta=aendl;coutb=bendl;
}
int main()
{
MyInt i1;
i1.accept(15, -25);
i1.print();-i1;
i1.print();
return 0;
}
©NIIT OOPS/Lesson 8/Slide 13 of 27

14. Polymorphism
Pre and Post Increment and Decrement
Operators
Prefix application of the operator
Causes the variable to be incremented before it is
used in an expression
Causes the operator function with no argument to
be invoked by the compiler
Postfix application of the operator
Causes the variable to be incremented after it is
used in an expression
Causes the operator function with an int
argument to be invoked by the compiler
©NIIT OOPS/Lesson 8/Slide 14 of 27

15. Polymorphism
Overloading Pre and Post Increment and
Decrement Operators
Example:
#includeiostream
class MyNum
{
private:
int number;
public:
...
/* Operator */
MyNum operator ++();//Pre Increment
MyNum operator ++(int);//Post
//Increment
};
©NIIT OOPS/Lesson 8/Slide 15 of 27

16. Polymorphism
Overloading Pre and Post Increment and
Decrement Operators (Contd.)
MyNum MyNum ::operator ++() //Pre
//Increment
{
MyNum temp;
number = number + 1; //First
//Increment number
temp.number = number; // Then Assign The
//Value To temp
return temp; //Return The
//Incremented Value
}
©NIIT OOPS/Lesson 8/Slide 16 of 27

17. Polymorphism
Overloading Pre and Post Increment and
Decrement Operators (Contd.)
MyNum MyNum ::operator ++(int) //Post
//Increment
{
MyNum temp;
temp.number = number; //First Assign
//The Current Value Of
//number To temp
number = number + 1; // Then Increment
//number
return temp; // Return The
//Original Value
}
©NIIT OOPS/Lesson 8/Slide 17 of 27

18. Polymorphism
Overloading Binary Operators
Example:
#includeiostream
class MyNum
{
private:
int number;
public:
MyNum(); MyNum(int);
/* Operator */
MyNum operator +(MyNum);
...
};
©NIIT OOPS/Lesson 8/Slide 18 of 27

19. Polymorphism
Overloading Binary Operators (Contd.)
MyNum MyNum ::operator +(MyNum N)
{
MyNum temp;
temp.number = number+N.number;
return temp;
}
©NIIT OOPS/Lesson 8/Slide 19 of 27

20. Polymorphism
Just a Minute…
Modify the existing employee class such that when the
following statements are given in the main() function,
the program successfully compares the basic salary of
the employees and displays the given message.
#include iostream
void main()
{
Employee eObj1, eObj2;
eObj1.getdata(); //Accepts data
eObj2.getdata();
if(eObj1eObj2)
cout “Employee 1 draws less salary
than Employee 2”;
©NIIT OOPS/Lesson 8/Slide 20 of 27

21. Polymorphism
Just a Minute…(Contd.)
else
cout “Employee 2 draws less salary
than Employee 1”;
}
©NIIT OOPS/Lesson 8/Slide 21 of 27

22. Polymorphism
Problem Statement 6.P.3
Consider the following class declaration:
#includeiostream
class distance
{
int length;
public:
distance(int);void operator =(distance);
};
Define the member-functions of the above class. The
'operator =()’ function should overload the ‘=’
operator to assign the value of an object of the
distance class to another object of the distance class.
The operator function should display a meaningful
message.
©NIIT OOPS/Lesson 8/Slide 22 of 27

23. Polymorphism
Problem Statement 6.P.4
Modify the existing employee class such that when the
following statements are given in the main() function,
the program successfully increments the basic salary of
the employee with the given amount.
#include iostream
void main()
{
Employee eObj1;
eObj1.getdata(); //Accepts data
eObj1 += 1000;
}
©NIIT OOPS/Lesson 8/Slide 23 of 27

24. Polymorphism
Summary
In this lesson, you learned that:
The term polymorphism has been derived form the
Greek words ‘poly’ and ‘morphos’, which means
‘many’ and ‘forms’, respectively
Function overloading is the process of using the same
name for two or more functions
The number, type, or sequence of parameters for a
function is called the function signature
Static polymorphism is exhibited by a function when it
exists in different forms
©NIIT OOPS/Lesson 8/Slide 24 of 27

25. Polymorphism
Summary (Contd.)
Operator overloading refers to providing additional
meaning to the normal C++ operators when they are
applied to user-defined data types
Operator overloading improves the clarity of user-
defined data types
The predefined C++ operators can be overloaded by
using the operator keyword
Operators may be considered as functions internal to
the compiler
Operators may be classified into two types: Unary and
Binary
Unary operators work with one operand
©NIIT OOPS/Lesson 8/Slide 25 of 27

26. Polymorphism
Summary (Contd.)
Unary operators can be classified as:
Simple prefix unary operators, for example, ! and -
Pre and post increment and decrement operators
A prefix unary operator may be defined by a member
function taking no parameter or a non-member
function taking one parameter
In order to avoid confusion between pre and post-fix
operators, all postfix unary operators take in a dummy
integer
Binary operators work with two operands
©NIIT OOPS/Lesson 8/Slide 26 of 27

27. Polymorphism
Summary (Contd.)
Overloading a binary operator is similar to overloading
a unary operator except that a binary operator
requires an additional parameter
In order to understand their overloading better, binary
operators may be classified as follows:
Simple operators, like + - * / % += -=
Comparison operators, like = = !=
==
The assignment operator =
The insertion and extraction operator
©NIIT OOPS/Lesson 8/Slide 27 of 27