Polymorphism and Virtual Functions Andy Wang Object Oriented Programming in C++ COP 3330

A Motivational Example In the previous example, we may have many sub- categories of Students With many different types of grade reports It would be great to store one list of students, and print out ALL grade reports with a loop Student list[30000]; for (int j = 0; j < size; j++) list[i].GradeReport();

Problems… The items in the array are base-class Student objects Base class objects do not know about subtypes (Grads and Undergrads) No such information is stored in the array Everything in an array needs to be the same type and size The GradeReport function being called is the Student class version Want to call the Grad version for graduate students and Undergrad version for undergraduate students Create separate arrays? Not realistic for many subtypes

A Base Class Pointer Property Normally, a pointer can only point to one type However, there is a special rule for inheritance A pointer to a base class type can be pointed at an object derived from the base class Similarly, a base class reference variable can refer to an object derived from that base class Examples Student s; Grad g; Undergrad u; Student *sp1, *sp2, *sp3; sp1 = &s; // pointing at Student object sp2 = &g; // pointing at Grad object sp3 = &u; // pointing at Undergrad object

Heterogeneous List A single array of pointers to a base class These pointers can point to any objects derived from that base Thus, we have created a list of various types of objects Without breaking the array rules All pointers have the same type—a pointer to the base class All pointers have the same size Student *list[30000]; list[0] = &g; list[1] = &u; list[2] = new Grad; …

Virtual Functions Which version of GradeReport will be run? If we have the following: for (j = 0; j < size; j++) list[j]->GradeReport(); This still calls the Student version of GradeReport list[j].GradeReport is bound to the Student version at compile time Compiler cannot guess the version of object at run time If we want to run the correct version at runtime, we need to achieve late (dynamic) binding

Virtual Functions The keyword virtual will do the trick To override a base class function when it is called through a pointer, declare the function to be virtual class Student { public: virtual void GradeReport(); }; Now when GradeReport is called through a base-class pointer, the program will run the appropriate version

Example Student s; Grad g; Undergrad u; Student *sp1, *sp2, *sp3; sp1 = &s; // pointing at Student object sp2 = &g; // pointing at Grad object sp3 = &u; // pointing at Undergrad object sp1->GradeReport(); // runs Student’s version sp2->GradeReport(); // runs Grad’s version sp3->GradeReport(); // runs Undergrad’s version

Pure Virtual Function Suppose you do not want to do anything for the Student’s version of GradeReport You can omit the definition virtual void GradeReport()=0; A virtual function without a definition is a pure virtual function

Abstract Class Any class that has at least one pure virtual function is an abstract class An abstract class cannot be instantiated Abstract classes are generally used as base classes They are intended to be a place to declare data and functions common to classes derived from them Abstract class can still be used to build pointers, to take advantage of virtual functions Example abstract class Shape Shape s; // illegal Shape *sptr; // legel

Employee Example http://www.cs.fsu.edu/~myers/cop3330/examples/inh er/employee/ Hierarchy of derived classes based on a class called Employee Goal is to store the employee information and handle paycheck printing Notice the virtual PrintCheck function and the building of heterogeneous list

employee.h #ifndef _EMPLOYEE_H #define _EMPLOYEE_H class Employee { public: virtual void PrintCheck()=0; protected: float netPay; Employee(); Employee(char *n, char *a, char *ssn); char name[30]; char address[90]; char socSecNumber[12]; };

employee.h class Temporary : public Employee { public: Temporary(char *n, char *a, char *ssn, float hw, float hr); Temporary(); void PrintCheck(); private: float hoursWorked; float hourlyRate; };

employee.h class Permanent: public Employee { public: static float benefitDeduction; protected: Permanent(char *n, char *a, char *ssn); Permanent(); void PrintCheck()=0; };

employee.h class Hourly : public Permanent { public: Hourly(char *n, char *a, char *ssn, float hw, float hr); Hourly(); void PrintCheck(); private: float hoursWorked; float hourlyRate; };

employee.h class Salaried: public Permananet { public: Salaried(char *n, char *a, char *ssn, float wp); Salaried(); void PrintCheck(); private: float weeklyPay; }; #endif

What’s going on?

employee.cpp #include <iostream> #include <cstring> #include “employee.h” using namespace std; float Permanent::benefitDeduction=100.00; Employee::Employee() { cout << “\nType employee name, followed by <Enter>: “; cin.getline(name, 30); cout << “\nType employee address, followed by <Enter>: “; cin.getline(address,80); cout << “\n”type employee social security number, followed by <Enter>: “; cin.getline(socSecNumber, 12); }

employee.cpp Employee::Employee(char *n, char *a, char *ssn) { strcpy(name, n); strcpy(address, a); strcpy(socSecNumber, ssn); } Temporary::Temporary() { cout << “\nType number of hours worked, followed by <Enter>: “; cin >> hoursWorked; cout << “\nType hourly rate, followed by <Enter>: “; cin >> hourlyRate;

employee.cpp Temporary::Temporary(char *n, char *a, char *ssn, float hw, float hr):Employee(n, a, ssn) { hoursWorked = hw; hourlyRate = hr; }

employee.cpp void Temporary::PrintCheck() { netPay = hoursWorked*hourlyRate; cout << "\n\n____________________________________"; cout << "\n\nPAY TO THE ORDER OF: " << '\t' << name; cout << "\n\t\t\t" << address; cout << "\n\t\t\t" << socSecNumber << '\n'; cout << "\nEMPLOYEE CLASS: Temporary"; cout << "\n\nHOURS: " << hoursWorked; cout << "\nRATE: " << hourlyRate; cout << "\n\nTHE AMOUNT OF **********$" << netPay << '\n'; cout << "\n\n________________________________\n\n"; };

employee.cpp Permanent::Permanent() { } Permanent::Permanent(char* n, char* a, char* ssn): Employee(n, a, ssn) { } Hourly::Hourly() { cout << "\nType number of hours worked, followed by <Enter>: "; cin >> hoursWorked; cout << "\nType hourly rate, followed by <Enter>: "; cin >> hourlyRate; };

employee.cpp Hourly::Hourly(char* n, char* a, char* ssn, float hw, float hr):Permanent(n, a, ssn) { hoursWorked=hw; hourlyRate=hr; };

employee.cpp void Hourly::PrintCheck() { netPay = (hoursWorked*hourlyRate) - benefitDeduction; cout << "\n\n____________________________________"; cout << "\n\nPAY TO THE ORDER OF: " << '\t' << name; cout << "\n\t\t\t" << address; cout << "\n\t\t\t" << socSecNumber << '\n'; cout << "\nEMPLOYEE CLASS: Hourly"; cout << "\n\nBENEFITS DEDUCTION: " << benefitDeduction; cout << "\nHOURS: " << hoursWorked; cout << "\nRATE: " << hourlyRate; cout << "\n\nTHE AMOUNT OF **********$" << netPay << '\n'; cout << "\n\n_________________________________\n\n"; };

employee.cpp // Other member data is solicited by the constructors for // Permanent and Employee classes Salaried::Salaried() { cout << "\nType weekly salary, followed by <Enter>: "; cin >> weeklyPay; }; Salaried::Salaried(char* n, char* a, char* ssn, float wp): Permanent(n, a, ssn) { weeklyPay=wp;

employee.cpp void Salaried::PrintCheck() { netPay = weeklyPay - benefitDeduction; cout << "\n\n_____________________________________"; cout << "\n\nPAY TO THE ORDER OF: " << '\t' << name; cout << "\n\t\t\t" << address; cout << "\n\t\t\t" << socSecNumber << '\n'; cout << "\nEMPLOYEE CLASS: Salaried"; cout << "\n\nBENEFITS DEDUCTION: " << benefitDeduction; cout << "\nSALARY: " << weeklyPay; cout << "\n\nTHE AMOUNT OF *********$" << netPay << '\n'; cout << "\n\n_________________________________\n\n"; };

utility.h #ifndef _UTILITY_H #define _UTILITY_H void Terminate(); // Ask if the user is ready to quit; return 1 if ‘y’ or ‘Y’ int ReadyToQuit(); // Freeze the screen until the user types a character void WaitForUser(); // Set C++ format flags for numeric output void SetNumeric(void); #endif

utility.cpp #include <iosteram> #include <cctype> #include <iomanip> #include “utility.h” using namespace std; void Terminate() { char any; cout << “\nPress ‘x’ followed by ENTER to exit the program…”; cin >> any; cout << “\nPROCESSING COMPLETED … GOOD EYE”; }

utility.cpp int ReadyToQuit() { char ans; cout << "\nDo you wish to run the program again (Y for yes, N for no)? "; cin >> ans; ans = toupper(ans); while ((ans !='Y') && (ans!='N')) { cout << "\nPlease answer again with Y or N"; cout << "\n\tRun the program again? "; } return(ans =='N'); // returns 1 when ready to quit

utility.cpp void WaitForUser(void) { cout << "\nPress 'c' followed by Enter to continue ..."; char any; cin >> any; cin.get(); // pick up newline cout << '\n'; } void SetNumeric(void) { cout << setw(8) << setprecision(2); cout.setf(ios::fixed, ios::floatfield); cout.setf(ios::showpoint);

main.cpp #include <iostream> #include “employee.h” #include “utility.h” using namespace std; int main() { Employee *emps[6]; // array of Employee pointers cout << “\n\nCreating a temporary employee pay record…”; Temporary t(“Clipper Decker”, “Clinton, NY”, “123456789”, 40.0, 5.25); emps[0] = &t;

main.cpp cout << “\n\nCreating an hourly employee pay record…”; Hourly h(“”Sparky Hirshfield”, “Deansboro, NY”, “234567890”, 30.5, 8.5); emps[1] = &j; cout << “\n\nCreating a salaried employee pay record…”; Salaried s(“Fenton Sugarman”, “Boston, MA”, “345678901”, 500.00); emps[2] = &s; WaitForUser();

main.cpp cout << “\n\nEnter data for a temporary employee pay record…”; Temporary *tEmp = new Temporary(“Bob”, “Here”, “111-11-1111”, 45.0, 15.45); emps[3] = tEmp; cout << “\n\n”Enter data for an hourly employee pay record…”; Hourly *hEmp = new Hourly; emps[4] = hEmp; cout << “\n\nEnter data for a salaried employee pay record…”; if (cin.peek() == ‘\n’) cin.get(); emps[5] = new Salaried;

main.cpp SetNumeric(); for (int j = 0; j < 6; j++) { cout << “\n\n”; emps[i]->Printcheck(); WaitForUser(); } Terminate(); cout << ‘\n’; return 0;