Presentation on polymorphism in c++.pptx

• The word polymorphism means having many forms.
• The word polymorphism is derived from Greek word
Poly which means many and morphos which means
forms.
• In simple words, we can define polymorphism as the
ability of a message to be displayed in more than one
form.
• A real-life example of polymorphism, a person at the
same time can have different characteristics. Like a
man at the same time is a father, a husband, an
employee.
• So the same person posseses different behavior in
different situations. This is called polymorphism.
• Polymorphism is considered as one of the important
features of Object-Oriented Programming.

Polymorphism
• Refers to ‘one name having many forms’,
‘one interface doing multiple actions’.
• In C++, polymorphism can be either
– static polymorphism or
– dynamic polymorphism.
• C++ implements static polymorphism through
– overloaded functions
– overloaded operators

Polymorphism
• Derived from the Greek - many forms
• Single name can be used for different purposes
• Different ways of achieving the polymorphism:
1. Function overloading
2. Operator overloading
3. Dynamic binding

• Compile time polymorphism: This type of
polymorphism is achieved by function
overloading or operator overloading.
• Function Overloading: When there are
multiple functions with same name but
different parameters then these functions are
said to be overloaded.
• Functions can be overloaded by change in
number of arguments or/and change in
type of arguments.

• Operator Overloading: C++ also provide
option to overload operators.
• For example, we can make the operator (‘+’)
for string class to concatenate two strings.
• We know that this is the addition operator
whose task is to add two operands.
• So a single operator ‘+’ when placed between
integer operands , adds them and when
placed between string operands,
concatenates them.

• Runtime polymorphism: This type of
polymorphism is achieved by Function
Overriding.
• Function overriding on the other hand
occurs when a derived class has a
definition for one of the member functions
of the base class. That base function is
said to be overridden.

Look alike but exhibit different characters

Overloading
• Overloading – A name having two or
more distinct meanings
• Overloaded function - a function having
more than one distinct meanings
• Overloaded operator - When two or more
distinct meanings are defined for an
operator

Overloading
• Operator overloading is inbuilt in C and
C++.
• ‘-’ can be unary as well as binary
• ‘*’ is used for multiplication as well as
pointers
• ‘<<‘, ‘>>’ used as bitwise shift as well as
insertion and extraction operators
• All arithmetic operators can work with any
type of data

Function Overloading
 C++ enables several functions of the same name to be
defined, as long as they have different signatures.
 This is called function overloading.
 The C++ compiler selects the proper function to call by
examining the number, types and order of the
arguments in the call.

 Overloaded functions are distinguished by their signatures
 Signature - Combination of a function’s name and its
parameter types (in order)
 C++ compilers encodes each function identifier with the
number and types of its parameters (sometimes referred to
as name mangling or name decoration) to enable type-safe
linkage.

17
Signature of a Function
• A function’s argument list (i.e., number and
type of argument) is known as the function’s
signature.
• Functions with Same signature - Two
functions with same number and types of
arguments in same order
• variable names doesn’t matter. For
instance, following two functions have
same signature.
void squar (int a, float b); //function 1
void squar (int x, float y);

20
Following code fragment overloads a function
name prnsqr( ).
void prnsqr (int i);
void prnsqr (char c);
void prnsqr (float f);
void prnsqr (double d);
//overloaded for floats #3
//overloaded for double floats #4
//overloaded for character #2
//overloaded for floats #3
//overloaded for integer #1

21
void prnsqr (int i)
{
cout<<“Integer”<<i<<“’s square is”<<i*i<<“n”;
}
void prnsqr (char c);
{
cout <<“No Square for characters”<<“n”;
}
void prnsqr (float f)
{
cout<<“float”<<f <<“’s square is”<<f *f<<“n”;
}
void prnsqr (double d)
{
cout <<“Double float”<<d<<“’s square is”<<d*d<<“n’;
}

using namespace std;
class sample-FO
{
public:
// function with 1 int parameter
void func(int x)
{
cout << "value of x is " << x << endl;
}
void func(double x)
{
cout << "value of x is " << x << endl;
}
void func(int x, int y)
{
cout << "value of x and y is " << x << ", " << y << endl;
}
};
int main() {
sample-FO obj1;
obj1.func(7);
obj1.func(9.132);
obj1.func(85,64);
return 0;
}
Output:
value of x is 7
value of x is 9.132
value of x and y is 85, 64

23
1) Signature of subsequent functions match previous function’s,
then the second is treated as a re-declaration of the first - Error
2) Signatures of two functions match exactly but the return type
differ, then the second declaration is treated as an erroneous
re-declaration of the first
For example,
float square (float f);
double square (float x);
// Differ only by return type so erroneous re-
declaration
//error
Resolution by Compiler when it sees second
function with same name

24
3) If the signature of the two functions differ in
either the number or type of their arguments,
the two functions are considered to be
overloaded.

25
CALLING OVERLOADED FUNCTIONS
Overloaded functions are called just like other
functions. The number and type of arguments
determine which function should be invoked.
For instance consider the following code fragment:
prnsqr (‘z’);
prnsqr (13);
prnsqr (134.520000012);
prnsqr (12.5F);

26
Steps Involved in Finding the Best
Match for a function call
A call to an overloaded function is resolved to a particular
instance of the function, there are three possible cases,
a function call may result in:
a) One match - A match is found for the function call.
b) No match - No match is found for the function call.
c) Ambiguous Match - More than one defined
instance for the function call.

27
1. Exact Match
For example, there are two functions with same name
afunc:
void afunc(int);
void afunc(double);
The function call
afunc(0);
is matched to void afunc(int); and compiler invokes
corresponding function definition
as 0 (zero) is of type int
//overloaded functions
//exactly match. Matches afunc(int)

28
2. A match through promotion
If no exact match is found, an attempt is made to
achieve a match through promotion of the actual
argument.
Recall that the conversion of integer types (char,
short, enumerator, int) into int - integral
promotion.

29
For example, consider the following code
fragment:
void afunc (int);
void afunc (float);
afunc (‘c’);
Will invoke afunc(int)
//match through the promotion;
matches afunc (int)

Compiler resolves
square (‘a’) to
square(int)

Compiler
resolves
square (‘a’) to
square(char)

32
3. A match through application of standard
C++ conversion rules
If no exact match or match through a promotion is
found, an attempt is made to achieve a match
through a standard conversion of the actual
argument. Consider the following example,
void afunc (char);
afunc (471);
//match through standard
conversion matches afunc (char)

33
• ‘int’ argument is converted to char

35
4. A match through application of a user-
defined conversion
• If all the above mentioned steps fail, then the
compiler will try the user-defined conversion in the
combinations to find a unique match.
• Member functions can also be overloaded

36
Default Arguments Versus Overloading
• Using default argument is also overloading,
because the function may be called with an
optional number of arguments.
• For instance, consider the following function
prototype:
float amount (float principal, int time=2,
float rate=0.08);

37
Now this function may be called by providing just one
or two or all three argument values. A function call
like as follows:
cout<<amount (3000);
will invoke the function amount() with argument
values 3000, 2, and 0.08 respectively. Similarly a
function call like
cout <<amount (3000,4);
Will invoke amount() with argument values 3000, 4
and 0.08
cout <<amount (2500,5,0.12);
Will invoke amount() with argument values 2500, 5,
and 0.12 respectively

Finding Gross Pay
• Three are three types of employees in Indian
railways. They are regular, daily wages and
consolidated employees. Gross Pay for the
employees are calculated as follows:
– regular employees - basic + hra + % of DA * basic
– Daily wages – wages per hour * number of hours
– Consolidated – fixed amount

PAC - Finding Gross pay
Input Output Logic Involved
Components for
calculating
gross pay
Gross pay Based on type of
employees –
Calculate gross
pay

Writing Functions
• Same function name for all three type of
employees
• More meaningful and elegant way of doing
things
• I prefer the name - calculate_Gross_Pay for all
types of employees

Case Study Implementation
• Member function search is overloaded
• Railways class has to be friend of train class to
access members of the class

Presentation on polymorphism in c++.pptx

Presentation on polymorphism in c++.pptx

More Related Content

Similar to Presentation on polymorphism in c++.pptx

Recently uploaded

Presentation on polymorphism in c++.pptx