1. Objectives 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

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

3. 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

4. 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 };

5. Problem
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

6. Problem
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.

7. Problem Statement
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);

8. Problem Statement
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

9. Need for Operator Overloading
To make operations on a user-defined data type as simple as the operations on a built-in data type

10. 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

11. 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)

12. 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; }

13. 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;

14. 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

15. 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 };

16. 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 }

17. 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 }

18. Overloading Binary Operators
Example:
#include<iostream>
class MyNum {
private:
int number;
public:
MyNum(); MyNum(int);
/* Operator */
MyNum operator +(MyNum);
... };

19. Overloading Binary Operators (Contd.)
MyNum MyNum ::operator +(MyNum N) {
MyNum temp;
temp.number = number+N.number;
return temp; }

20. 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”;

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

22. Problem Statement 6.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.

23. 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; }

24. 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

25. 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

26. 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

27. 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 << >>