Inheritance

1. Inheritance

2. Code Reuse • Essential to the software development process • Do not have to “reinvent the wheel” • Are using software components that have been debugged through previous use • So far, we have seen the following examples of code reuse: • Functions (function libraries) • Classes (class libraries) • Composition (aggregation) • Inheritance is another tool that promotes code reuse.

3. Object Relationships There are three basic relationships that objects can have: 1. “uses a” 2. “has a” 3. “is a” 1. “uses a” • When an object uses another object by calling a public method of that object

4. Object Relationships (con’t) 2. “has a” • Examples: • A course section has a student list • A person has a birth date • A movie has a start time • Implemented using composition (aggregation) • Graphically represented by an aggregation hierarchy

5. Object Relationships (con’t) 3. “is a” • One object is a more specialized version of another: • A car is a vehicle • A sorted list is a list • A student is a person • A professor is a faculty member • A lecturer is a faculty member • Implemented using inheritance • Graphically represented by an inheritance hierarchy

6. UMBCCOMMUNITYMEMBER STUDENT FACULTY MEMBER GRADUATESTUDENT UNDERGRADSTUDENT PROFESSOR LECTURER An Inheritance Hierarchy

7. Inheritance Hierarchy • Objects at the top levels are more general in nature than the ones on the lower levels. • The lower you go in the hierarchy, the more specialized the objects become. • Inheritance is transitive across levels • A “graduate student” is a “student.” • A “student” is a “UMBC community member.” • Therefore, a “graduate student” is also a “UMBC community member.”

8. Inheritance and Classes • The more general class is referred to as a base class (or superclass). • The more specialized class is referred to as a derived class (or subclass). • A base class contains all that is common among its derived classes. • The attributes (data) and behaviors (methods) of a base class are inherited by all its derived classes. • Derived classes use, extend, modify, or replace the base class’ behaviors.

9. Inheritance and OOP • Inheritance is an abstraction for sharing similarities among classes while preserving their differences. • Inheritance allows us to group classes into families of related types, allowing for the sharing of common operations and data. • Multiple inheritance is possible, but not adviseable. (We will not address it.) • Again, inheritance promotes code reuse.

10. Inheritance in C++ • C++ provides three types of inheritance • Public inheritance is used to implement the “is a” relationship. • Private inheritance is use to implement the “is-implemented-in-terms-of” relationship, similar to composition. • No one knows what protected inheritance is. • Our discussions are limited to publicinheritance

11. Public Inheritance Assume that class D (“Derived”) publicly inherits from class B (“Base”). • Every object of type D is a B, but not vice versa. • D is a more specialized version of B. • Anywhere an object of type B can be used, an object of type D can be used just as well, but not vice versa. (Adapted from: “Effective C++”, 2nd edition, page 155)

12. A Simple Class Example // a military time class class Time { public: Time(int h = 0, int m = 0, int s = 0); void setTime (int h, int m, int s); void increment( ); void printTime ( ) const; private: int hrs; // 0 - 23 int mins; int secs; };

13. Time Methods Time::Time (int initHrs, int initMins, int initSecs) : hrs (initHrs), mins (initMins), secs (initSecs) { // no code – uses member initialization list // should validate } void Time::setTime (int hours, int minutes, int seconds) { // should validate hrs = hours; mins = minutes; secs = seconds; }

14. Time Methods (con’t) void Time::increment ( ) // increments by one second { secs++; if (secs > 59) { secs = 0; mins++; if (mins > 59) { mins = 0; hrs++; if (hrs > 23) hrs = 0; } } }

15. Time Methods (con’t) // print time as hh:mm:ss with leading zeroes void Time::printTime ( ) const { if (hrs < 10) cout << '0'; cout << hrs << ':'; if (mins < 10) cout << '0'; cout << mins << ':'; if (secs < 10) cout << '0'; cout << secs; }

16. A Derived Class: Extended Time class ExtTime: public Time { public: enum ZoneType = {EST, CST, MST, PST, EDT, CDT, MDT, PDT}; ExtTime(int h = 0, int m = 0, int s = 0, ZoneType z = EST); void setExtTime (int h, int m, int s, ZoneType z); void printExtTime( ) const; private: ZoneType zone; };

17. What is Inherited? • ExtTime publicly inherits from Time. • Time is the base class, ExtTime is the derived class. • Inherited from base class Time: • setTime( ), increment( ), printTime( ), hrs, mins, secs • Not inherited: • Time constructor (constructors cannot be inherited) • Added by derived class ExtTime: • setExtTime( ), printExtTime( ), zone

18. Protected Access A base class can give a derived class direct access to some members by placing them in the protected section. Only derived classes (and their friends) can access protected members. class Time { public: // same code as before protected: // potential encapsulation violation! int hrs, mins, secs;};

19. Access Summary • Public in the base class • Is public in the derived class • Accessible by derived member functions, friends, and non-member functions • Protected in the base class • Is protected in the derived class • Accessible by derived member functions and friends • Private in the base class • Is not accessible by the derived class • Must use base class public or protected functions to access

20. ExtTime Constructor The ExtTime constructor calls the Time (base class) constructor using a member initialization list. Without this, Time’s default constructor would be called. Note thattheTime constructor is called first, then the ExtTime constructor body is executed. (Destruction would take place in reverse order.) ExtTime::ExtTime (int Hrs, int Mins, int Secs, ZoneType Zone) : Time (Hrs, Mins, Secs) { zone = Zone; }

21. ExtTime::setExtTime setExtTime calls Time::SetTime to set (private) hrs, mins, and secs inherited from Time. void ExtTime::setExtTime(int h, int m, int s, ZoneType z) { SetTime (h, m, s); zone = z; }

22. ExtTime::printExtTime void ExtTime::printExtTime ( ) const { static char* zoneString[8] = { “EST", "CST", "MST", "PST", "EDT", "CDT", "MDT", "PDT" }; printTime ( ); // a base class method cout << ' ' << zoneString[zone]; }

23. Using ExtTime int main ( ) { ExtTime eTime (12, 0, 0); // noon, EST eTime.printExtTime ( ); // ExtTime method eTime.increment ( ); // an inherited method eTime.printTime ( ); // just prints hh:mm:ss eTime.setExtTime (13, 12, 7, ExtTime::PST); eTime.printExtTime ( ); // ExtTime method return 0;}

24. Using Time and ExtTime int main( ) { Time t(5, 14, 10), *tPtr = &t; ExtTime et1(3, 7, 12), et2(14, 9, 20), *etPtr = &et1; t = et1; // t is now 05:14:10 et2 = t; // syntax error! tPtr = &et1; // base class pointer points to derived object tPtr->printTime( ); // prints 03:07:12 etPtr = &t; // syntax error! return 0; }

25. Mixing Base and Derived Class Objects and Pointers • A derived class object may be assigned to a base class object because a derived object “is a” base object. Member slicing will occur. • However, a base class object may not be assigned to a derived class object. • A base class pointer may point to a derived class object. • However, a derived class pointer may not (without casting) point to a base class object.

26. Overloaded Assignment Operator • Note that an overloaded base class assignment operator (operator=) is not inherited and not called automatically from the derived class overloaded assignment operator.

27. Time::operator= Time& Time::operator= (const Time& rhs) {if (this != &rhs) // self-assignment check{ hrs = rhs.hrs; mins = rhs.mins; secs = rhs.secs; } return *this; // enables x = y = z }

28. Erroneous ExtTime::operator= ExtTime& ExtTime:: operator=(const ExtTime &rhs) {if (this != &rhs) zone = rhs.zone; return *this; }

29. What Happens? ExtTime eTime1 (12, 30, 0, ExtTime::EST); ExtTime eTime2 (13, 45, 30, ExtTime::PDT); // assignment only changes the zone eTime2 = eTime1; // now eTime2 is 13:45:30 EST

30. Correct ExtTime::operator= ExtTime& ExtTime::operator=(const ExtTime &rhs){ if (this != &rhs) { // explicitly call base class op= Time::operator= (rhs); zone = rhs.zone; } return *this;}

31. Notes on Inheritance • Base class constructors and destructors are not inherited. • The base class constructor (destructor) will automatically be invoked when the derived class is constructed (destroyed). • The base class constructor will be called first. • The derived class destructor will be called first (objects are destroyed in the reverse order they are constructed). • Base class operator= is not inherited and not automatically called by derived class operator= • Friendship is not inherited. That is, a friend of the base class is not automatically a friend of the derived class. (Friendship must be granted.)

32. Specialization by Overriding • An inheritance hierarchy shows how more specialized classes are derived from more general classes. • We have already seen specialization through the addition of new methods and data members in a derived class (ExtTime). • Another mechanism for specialization is overriding base class member functions. • This is achieved by defining a derived class method with the exact same signature as a base class method. The derived class method “hides” the base class method from the user.

33. Overriding is Not Overloading • Recall that overloading a function means using the same function name, but with different parameters. • Overriding a function means redefining a function using the same name and parameters (i.e., signature). (This is possible only with inheritance.)

34. Overloading Example • In our Time/ExtTime example, ExtTime extended Time by adding new methods and data members. But suppose ExtTime was defined a little differently. • Suppose instead of having printExtTime( ), the ExtTime class redefined printTime( ).

35. Revised ExtTime Class With Function Overriding class ExtTime: public Time { public: enum ZoneType = {EST, CST, MST, PST, EDT, CDT, MDT, PDT}; ExtTime(int h = 0, int m = 0, int s = 0, ZoneType z = EST); void setExtTime (int h, int m, int s, ZoneType z);void printTime( ) const; // function overriding private: ZoneType zone; };

36. ExtTime::printTime( ) void ExtTime::printTime ( ) const {static char* zoneString[8] = {“EST”, “CST”, “MST”, “PST”, “EDT”, “CDT”, “MDT”, “PDT”}; Time::printTime( ); // explicit call cout << ‘ ‘ << zoneString[zone]; }

37. main( ) must call Time::printTime( ) explicitly because it is lexically “hidden” by ExtTime::printTime( ). int main ( ){ ExtTime eTime (12, 0, 0); // noon, EST eTime.increment( ); // an inherited method eTime.printTime( ); // overriding eTime.Time::printTime( ); // using Time’s printTime() return 0; }