Inheritance

1. Inheritance

2. Learning Objectives • To understand inheritance terminology • To understand multiple inheritance • To understand diamond inheritance and virtual inheritance • To understand protected access privilege • To understand the call order of constructor and destructor in inheritance • To understand function overriding

3. Inheritance • By nature we commonly group objects that have a common attributes and behaviors into classes (categories)., e.g. animals, vehicles, and human. • Under each of these classes there can be 0, 1, or more subclasses (subcategories).

4. Example 1/2 • Under the animal class, we can create three subclasses: bird, mammal and fish. • Animal, bird, mammal and fish are classes. • Bird, mammal and fish are subclasses of animal. • Eagle, parrot, whale, monkey, goldfish and shark are instances/objects. (They can actually be sub-subclasses.)

5. The "is-a" Relationship • Note the following statements: • Eagle is a bird. Parrot is a bird. Both are also animals. • Cat is a mammal. Monkey is a mammal. Both are also animals. • Goldfish is a fish. Shark is a fish. Both are also animals. • A bird is different from a mammal, a mammal is different from a fish, and a fish is different from a bird. • Even though they are all different among one another, they are the same in regard that they are all animals. 5

6. Example 2/2 • Under the Human class, we can create 2 subclasses: Lecturer and Student. • Sharaf and Manoj are instances of Lecturer. Tom and John are instances of Student. • Sharaf, Manoj, Tom and John are also Humans. 6

7. Inheritance Terminology • The "is-a" relationship between a superclass and its subclasses is commonly referred to as inheritance. • We say that a subclass "inherits from"/"derives from" a superclass. Example: Bird inherits from Animal. • Subclass inherits all the characteristics (attributes and methods) from its superclass. • All objects of Bird have a common set of attributes and methods of Bird, and also inherit a common set of attributes and behaviors from Animal. • Example: If animals have skin, then birds also have skin. • Inheritance promotes code reuse and simplifies code maintenance in the long run. 7

8. Definition of Inheritance • Inheritance is the mechanism which allows a class B to inherit attributes and methodsof a class A. We say "B inherits from A". • Objects of class B have direct access to non-private attributes and methods of class A. • If class B inherits from class A, then A is called the superclass/base class/parent class) of B. B is called the subclass/derived class/child class) of A. • Superclass is more general than subclass • Subclass is more specific than superclass Superclass/Base class/Parent class Is-a Subclass/Derived class/Child class 8

9. Inheritance in UML Class Diagram • From the following UML Class Diagram • We know that Human is the superclass. • Lecturer and Student are subclasses of Human class. 9

10. Superclass: Human • The C++ Definition for the superclass Human: class Human { string name; public: Human(string name) : name(name) {} void speak(string sentence) { cout << "My name is " << name << ". " << sentence << endl; } }; 10

11. Defining Subclasses • To indicate that a subclass inherits from superclass, we use a single colon ":", followed by an access privilege keyword (usually public) and the name of the superclass in the declaration. class subclass :public superclass : <constructor initialization list> { ... }; • In most cases, subclass' constructor should initialize superclass' attributes. 11

12. Subclass Lecturer • Hence, the declaration for Lecturer is as follows: class Lecturer : public Human { string room; public: Lecturer (string name, // 'name' is for initializing // superclass' attribute. string room); }; 12

13. Initializing Superclass from Subclass • Wrong way of initializing superclass from subclass: Lecturer (string name, string room) { this->name = name; // Compile-error. this->room = room; } or Lecturer (string name, string room) : name(name), room(room) {} // Compile-error. • The reason is name is a private attribute of superclass hence cannot be directly accessed by subclass.

14. Calling Superclass Constructor • The correct way of initializing superclass is to invoke superclass constructor at subclass' constructor initializer list. Lecturer (string name, string room) : Human(name) { // Correct. this->room = room; } "calls" the Human constructor with the argument name. or Lecturer (string name, string room) : Human(name), room(room) { } // Correct. • Note that we are reusing existing code (Human constructor). 14

15. Inheritance Example class Human { string name; public: Human (string name) : name(name) {} void speak (string sentence) { cout << "My name is " << name << ". " << sentence << endl; } }; class Lecturer : public Human { string room; public: Lecturer (string name, string room) : Human(name), room(room) {} }; class Student : public Human { double CGPA; public: Student (string name, double CGPA) : Human(name), CGPA(CGPA) {} }; int main() { Human h("Hugo"); Lecturer l("Lee", "BR1111"); Student* s = new Student ("Sarah", 3.99); h.speak ("Ha"); l.speak ("Hi"); // Human::speak() s->speak ("Ho");// Human::speak() delete s; } Output: My name is Hugo. Ha My name is Lee. Hi My name is Sarah. Ho

16. Simpler Code Maintenance • Now assume that both Lecturer and Student need a new attribute called address. Instead of adding the address at subclasses Lecturer and Student directly, we should add the address at superclass Human because the attribute will be inherited by both Lecturer and Student. • The C++ Definition for the superclass Human: class Human { string name; string address; public: Human(string name, string address = "") : name(name), address(address) {} ... 16

17. Multiple Levels of Inheritance • We can have more than one level of inheritance. • For example, the Student class can be the superclass of LocalStudent and ForeignStudent. (Ignore the attribute address we discuss in previous slide.)

18. Multiple Levels of Inheritance • A subclass inherits the attributes and methods of all of its superclasses: • A ForeignStudentobject will, therefore, inherit: • all of the attributes and methods of Humanclass, • plus the attributes and methods of Student class, • plus the attributes and methods of ForeignStudentclass. 18

19. Multiple Levels of Inheritance • A subclass constructor can invoke only theimmediate superclass constructor, not the super-superclass constructor, unless virtual inheritanceis used. class LocalStudent : public Student { string icno; public: LocalStudent (string name, double CGPA, string icno) : Human(name), // Compile error, attempt to call // super-superclass constructor. Student(name, CGPA), icno(icno) {} }; 19

20. Multiple Levels of Inheritance • Sample constructor for LocalStudentand ForeignStudent. class LocalStudent : public Student { string icno; public: LocalStudent (string name, double CGPA, string icno) : Student(name, CGPA), // Call immediate superclass constructor, okay icno(icno) {} }; class ForeignStudent : public Student { string passportno; public: ForeignStudent (string name, double CGPA, string passportno) : Student(name, CGPA), passportno(passportno) {} // okay }; 20

21. Multiple Inheritance • Multiple inheritance is NOT the same as "multiple levels of Inheritance". • Multiple inheritance occurs when a class has 2 or more direct/immediate superclasses. • Use comma "," to separate superclasses. class C : public A, public B { public: C(…) : A(…), B(…) // Constructor initialization list. {}}; A B Constructor for class A Constructor for class B C

22. Diamond Inheritance Problem • Multiple inheritance may introduce diamond inheritance problem, which arises when 2 classes B1 and B2 inherit from A, and class C inherits from both B1 and B2. • The problem is C would have duplicate sets (2 sets) of the members inherited from A, which might not be desirable. • If one set of members of A is preferred at C, we can use virtual inheritance to avoid duplicate sets. A B2 B1 C 22

23. Virtual Inheritance • Diamond Inheritance Problem • class A { ... }; • class B1: public A { ... }; • class B2: public A { ... }; • class C: public B1, public B2 { • public: • C(...) : B1(...), B2 (...) { } • }; • Solution: virtual inheritance • class A {}; • class B1: virtual public A {}; • class B2: virtual public A {}; • class C: public B1, public B2 { • public: • C(...) : A(...), B1(...), B2 (...){} • // Must call super-superclass constructor. • }; A B1 B2 C 23

24. protected Access Privilege • Recall from the previous lecture the following classes: class Human { string name; // private ... }; class Lecturer : public Human { string room; public: Lecturer (string name, string room) : Human(name), room(room) {} // 'name' is private in Human ... }; • The reason we have to initialize the attribute name via constructor initialization list is subclass cannot access superclass' private members.

25. protected Access Privilege • If a class member is declared as protected, then it is accessible to the class itself and its subclasses. class Human { protected: string name; ... }; class Lecturer : public Human { string room; public: Lecturer (string name, string room) { this->name = name; // Fine since 'name' is protected. ... };

26. protected Access Privilege • However, same as private member, a protected member of a superclass is not accessible at subclass' constructor initilizer list. class Human { protected: string name; ... }; class Lecturer : public Human { string room; public: Lecturer (string name, string room) { : name(name), // Error, 'name' is not accessible here. room(room) { } ... };

27. protected Access Privilege • We use hash symbol "#" to denote protected access privilege in UML Class Diagram.

28. Accessing Superclass' Private Attribute • Subclass can access/modify superclass' private attributes indirectly via the public/protected get/set methodsprovided by superclass. class Super { int z; public: void setZ (int z) { this->z = z; } intgetZ() { return z; } }; class Sub: public Super { public: Sub(int z) { setZ (z); // superclass' setZ } }; int main() { Sub s(3); cout << s.getZ() << endl; s.setZ (33); // Fine cout << s.getZ() << endl; } Output: 3 33

29. Function Overriding • A subclass can override a superclass method by supplying a new version of that method with the same signature. • When the method is invoked in the subclass, the subclass version is automatically selected. class Human { public: void eat() { cout << "Eating\n"; } void speak() { cout << "I'm a human\n"; } }; class Student : public Human { public: void speak() { // Override superclass' speak(). cout << "I'm a student\n"; } };

30. Function Overriding class Human { public: void eat() { cout << "Eating\n"; } void speak() { cout << "I'm a human\n"; } }; class Student : public Human { public: void speak() { // Override superclass' speak(). cout << "I'm a student\n"; } }; int main() { Human* h = new Human; Student* s = new Student; h->speak(); // call Human::speak() s->speak(); // call Student::speak() h->eat(); // call Human::eat() s->eat(); // call Human::eat() delete h; delete s; } Output: I'm a human I'm a student Eating Eating 30