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

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

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

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

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

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.

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);

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

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

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

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)

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

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;

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

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

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 }

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 }

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

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

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

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

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.

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

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

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

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

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