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 Programming Using C++/Session 11/Slide 1 of 27
Polymorphism

Static Polymorphism
 Refers to an entity existing in different physical forms
simultaneously

©NIIT Programming Using C++/Session 11/Slide 2 of 27

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 Programming Using C++/Session 11/Slide 3 of 27

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 Programming Using C++/Session 11/Slide 4 of 27

Polymorphism

Problem Statement 8.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 Programming Using C++/Session 11/Slide 5 of 27

Polymorphism

Problem Statement 8.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 Programming Using C++/Session 11/Slide 6 of 27

Polymorphism

Problem Statement 8.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 Programming Using C++/Session 11/Slide 7 of 27

Polymorphism

Problem Statement 8.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 Programming Using C++/Session 11/Slide 8 of 27

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 Programming Using C++/Session 11/Slide 9 of 27

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 Programming Using C++/Session 11/Slide 10 of 27

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 Programming Using C++/Session 11/Slide 11 of 27

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 Programming Using C++/Session 11/Slide 12 of 27
Polymorphism

Overloading Simple Prefix Unary Operators

(Contd.)
void MyInt ::accept(int x, int y)
{
a=x;b=y;
}
void MyInt ::print()
{
cout<<"a="<<a<<endl;cout<<"b="<<b<<endl;
}
int main()
{
MyInt i1;
i1.accept(15, -25);
i1.print();-i1;
i1.print();
return 0;
}
©NIIT Programming Using C++/Session 11/Slide 13 of 27
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 Programming Using C++/Session 11/Slide 14 of 27

Polymorphism

Overloading Pre and Post Increment and

Decrement Operators
Example:
#include<iostream>
class MyNum
{
private:
int number;
public:
...
/* Operator */
MyNum operator ++();//Pre Increment
MyNum operator ++(int);//Post
//Increment
};
©NIIT Programming Using C++/Session 11/Slide 15 of 27
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 Programming Using C++/Session 11/Slide 16 of 27

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 Programming Using C++/Session 11/Slide 17 of 27

Polymorphism

Overloading Binary Operators

Example:
#include<iostream>
class MyNum
{
private:
int number;
public:
MyNum(); MyNum(int);
/* Operator */
MyNum operator +(MyNum);
...
};
©NIIT Programming Using C++/Session 11/Slide 18 of 27
Polymorphism

Overloading Binary Operators (Contd.)

MyNum MyNum ::operator +(MyNum N)
{
MyNum temp;
temp.number = number+N.number;

return temp;
}

©NIIT Programming Using C++/Session 11/Slide 19 of 27

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(eObj1<eObj2)
cout<< “Employee 1 draws less salary
than Employee 2”;
©NIIT Programming Using C++/Session 11/Slide 20 of 27
Polymorphism

Just a Minute…(Contd.)
else
cout<< “Employee 2 draws less salary
than Employee 1”;
}

©NIIT Programming Using C++/Session 11/Slide 21 of 27

Polymorphism

Problem Statement 8.P.3

Consider the following class declaration:
#include<iostream>
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 Programming Using C++/Session 11/Slide 22 of 27
Polymorphism

Problem Statement 8.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 Programming Using C++/Session 11/Slide 23 of 27

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 Programming Using C++/Session 11/Slide 24 of 27

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 Programming Using C++/Session 11/Slide 25 of 27

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 Programming Using C++/Session 11/Slide 26 of 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 Programming Using C++/Session 11/Slide 27 of 27