1. DERIVED CLASSES AND INHERITANCE Moshe Fresko Bar-Ilan University Object Oriented Programing 2006-2007

2. Derived Classes Consider the example (Composition): struct Employee { string firstName, lastName ; char middleInitial ; Date hiringDate ; short department ; // … } struct Manager { Employee emp ; set group ; short level ; // … } A Manager is an Employee. But compiler does not know it.

3. Derived Classes Better way: struct Manager: public Employee { set group ; short level ; // … } Manager is derived from Employee. (Derivation) Or Employee is a Base class for Manager. Manager has all the members of Employee in addition to its own members. A derived class inherits properties from its base, so the relationship is called Inheritance. Employee Manager

4. Derived Classes Manager is a subtype of Employee, so wherever Employee is needed Manager can be used. void f ( Manager m1, Employee e1) { Employee* elist[2] ; elist[0] = &m1 ; elist[1] = &e1 ; // … }

5. Casting If a class “ Derived ” has a public base class “ Base ” then a “ Derived* ” can be assigned to a variable of type “ Base* ” without explicit casting. The opposite conversion must be explicit. Manager is an Employee, but Employee is not necessarily a Manager. void g ( Manager mm, Employee ee) { Employee* pe = &mm ;// ok: Manager* pm = &ee ;// error: pm->level = 2 ;// Catastrophic pm = static_cast (pe) ; // works. pm->level = 2 ;// fine. // … }

6. Member Functions A member of a derived class can use the public and protected members of its base class. class Employee { string firstName, lastName; char middleInitial; public: void print() const ; string fullName() const { return firstName+ ‘ ’ +middleInitial+ ‘ ’ +lastName; } // … } class Manager: public Employee { // … public: void print() const ; // … } void Manager::print() const { cout << “ name is “ << fullName() << endl ;// but cannot use lastName, it is private }

7. Member Functions To call the version from the Base class void Manager::print() const { Employee::print() ;// print Employee information // Print Manager specific information cout << “ Level: ” << level << endl ; }

8. Constructors and Destructors Base constructor called first. Derived class either must specify the Base constructor or must count on the default Base constructor (if there is one). class Employee { string firstName, lastName; short department; public: Employee(const string& n, int d); /* … */ } class Manager: public Employee { set group; short level; public: Manager(const string&n, int d, int lvl); /* … */ } Employee::Employee(const string& n, int d) : lastName(n), department(d) { /* … */ } Manager::Manager(const string& n, int d, int lvl) : Employee(n,d), level(lvl) { /* … */ }

9. Constructors and Destructors First ctor of base class and then of derived class. First dtor of derived class and then of base class. class A { public: A() { cout << “ ctor:A() ” << endl ; } public: ~A() { cout << “ dtor:~A() ” << endl ; } } class B : public A { public: B() { cout << “ ctor:B() ” << endl ; } public: ~B() { cout << “ dtor:~B() ” << endl ; } } int main() { A a ; B b ; } // what will be the output of the program

10. Constructors and Destructors There must be a suitable ctor in Base class. class A { private: int val; public: A(int x) { val=x ;} } class B: public A { public: B(int x) : A(x) { } B(int x) { }// error B() : A(5) { } B() { }// error } class C: public A {// error no ctor for C }

11. Copying of class Objects Copying of class objects is defined by the copy constructor and assignments. class Employee { // … Employee& operator=(const Employee&); Employee(const Employee&); }; void f(const Manager& m) { Employee e=m ;// slicing Employee e2 ; e2 = m ; // Use employee part of Manager }

12. Class Hierarchies A derived class can itself be a base class. class Employee { /* … */ }; class Manager : public Employee { /* … */ }; class Director : public Manager { /* … */ }; Multiple Inheritance class Temporary { /* … */ }; class Secretary : public Employee { /* … */ }; class Tsec : public Temporary, public Secretary { /* … */ }; class Consultant : public Temporary, public Manager {/* … */};

13. Virtual Functions For Virtual Functions the compiler and loader will guarantee the correct correspondence. class Employee { string firstName, lastName; short department; // … public: Employee(const string& n, int dept); virtual void print() const; // … }; void Employee::print() const { cout << lastName << “ \t ” << department << endl ; }

14. Virtual Functions A function from a derived class with the same name and the same set of argument types as a virtual function in a base is said to override the function. class Manager : public Employee { set group ; short level ; // … public: Manager (const string& n, int dept, int lvl); void print() const ; // … } void Manager:print() const { Employee::print(); cout << “ \tlevel= ” << level << endl ; }

15. Virtual Function calls Polymorphism: Getting the right behavior from Employee ’ s functions independently of exactly what kind of Employee is actually used is called polymorphism: A type with virtual function is called a polymorphic type. void print_one_employee(Employee* ep) { ep->print() ; } int main() { Employee e( “ Brown ”, 1234) ; Manager m( “ Smith ”, 1234, 2) ; Employee* ep = &e ; print_one_employee ( ep ) ; ep = &m ; print_one_employee ( ep ) ; } // What will be the output ?

16. Abstract Classes Pure Virtual Functions: A virtual function is made pure by the initializer of =0 Abstract Class: A class with at least one virtual function is called an abstract class, no Objects of the abstract class can be created. class Shape { public: virtual void rotate(int) = 0 ; virtual void draw() = 0 ; }; Shape s ;// error Shape* sp ;// ok

17. Abstract Class An abstract class can be used as an interface and as a base for other classes. class Point { /* … */ }; class Circle: public Shape { public: void rotate(int x) { /* … */ } void draw() { /* … */ } Circle(Point p, int r); private: Point center; int radius; }

18. Exercise 1. Create a class NameWriter with a virtual function writeName that prints the name of the class. Derive A and B classes and override this function. 2. Create a list of 10 pointers to NameWriter. Fill them with pointers to objects of classes A and B. 3. Write a global function that calls writeName for a list of NameWriter-s. 4. For 2 call the function in 3. 5. Delete the virtual keyword from writeName function declaration and run the program again.