Chapter 4 Inheritance

1. Chapter 4Inheritance Bernard Chen Spring 2006

2. Objective • IS-A relationships and the allowable changes for derived classes • The concept of polymorphism • Public, private, and protected members and inheritance • Static vs. dynamic binding • Default constructor, copy constructor, and copy assignment operator • Abstract classes • Tricky stuff

3. 4.1 What is Inheritance? • Another mechanism for code reuse. • A process of deriving classes from a base class w/o disturbing the implementation of the base class. • Ex: Vehicleis a class Car is a Vehicle => Car derived from Vehicle

4. Figure 4.2 istringstream istream fstream ifstream IOS iostream stringstream ostream ostringstream ofstream

5. Polymorphism • Variables can reference objects of several type. When operation are applied to the variable, the operation appropriate to the referenced object is automatically selected. • Derived class is a new class which inherits all public & protected properties of a base class. • Derived class is type-compatible with its base class.

6. 4.2 Inheritance Basics • Public inheritance: all public members of the base class remain public in the derived class =>models is-a relationship =>mostly used. • Private inheritance: hidden all inherited members from the public => models has-a relationship.

7. General layout of public inheritance class Derived : public Base { //any member are not listed are inherited //except constructor, destructor, copy, constructor and operator= public: //new constructor and destructor if necessary //modify base member function //new function private: //new data member or private function //base members should be disable };

8. Inheritance cont. . . • Derived class inherits all member functions from the base class. It may accept, disallow, or redefine them. • Derived class can define new functions. • Derived class can access public and protected members of the base class.

9. Access rules

10. Constructor and Base class initialization • If there is no constructor in a derived class, a default zero-parameter constructor will be generated • Base class constructors can be explicitly called by name in the initializer list. Derived() : Base() {}

11. Constructor for the new exception class Underflow class Underflow : public underflow_error { public: underflow(const string & msg =“ “) : underflow_error(msg.c_str()) {} };

12. Overriding a method(member function) • Overriding base class methods: Derived class methods must have the same signature and compatible return types with the base class methods. • Partial overriding: overriding base class methods by adding more functionality.

13. Example of partial overriding class Workaholic : public Worker { public: void doWork() //overriding base method { Worker::doWork();// call base method drinkCoffee(); // new method Worker::doWork();// call base method } };

14. Bindings • Static binding: the decision about which function/type to use to resolve an overload is made at compile time. • Dynamic binding: the decision must be made at run time.

15. Worker w; Workaholic wh; . . . w.doWork(); wh.doWork(); figure 4.8 static binding Worker *wptr; cin>>x; if(x != 0) wptr = new Workaholic(); else wptr = new Worker(); . . . //which doWork is used ? wptr -> doWork(); Figure 4.9 dynamic binding Examples

16. Virtual • If a function is redefined in a derived class, it should be declared virtualin the base class. • Example: class Worker{ public: virtual void doWork(); };

17. Virtual Cont… • Constructors are “NEVER” virtual • Destructors should be virtual for base class => Let the computer know which one to call for deallocation.

18. Abstract • Abstract method, pure virtual function, has no meaningful definition in the base class and must always be defined in derived classes. • Abstract class: a class containing any abstract method = > can’t be instantiated and must be inherited. • Example: shape class

19. The abstract base class shape class Shape { public: Shape( const string & shapeName = "" ) : name( shapeName ) { } virtual ~Shape( ) { } virtual double area( ) const = 0; //abstract method bool operator< ( const Shape & rhs ) const { return area( ) < rhs.area( ); } virtual void print( ostream & out = cout const { out << name << " of area "<< area( ); } private: string name; }; //figure 4.13

20. General rules • Nonvirtual functions: Overloading is resolved at compile time. • Virtual functions: Overloading is resolved at run-time (Base class provide a default implementation) • Pure virtual functions Overloading is resolved at run-time. (Base class provide no default implementation)

21. 4.4 Tricky C++ Details • Changing the default value in a derived class is unsafe because doing so can create an inconsistency with virtual functions.

22. Cont… • When a method is declared in a derived class, it “hides” all methods of the same name in the base class => get away by partial overriding or using “using” directive

23. Illustration of hiding class Base{ public: virtual void bar(); }; class Derived{ public: void bar(int x); }; Void test( Base & arg1, Derived & arg2){ arg1.bar(); // call Base::bar() => OK arg1.bar(4); //call Base::bar(int) => fails for not arg2.bar(4); // call Derived::bar(int) => OK arg2.bar(); // fails b/c Derived::bar(int) has hidden Base::bar() }

24. Two ways to solve Hinding • Override the zero-parameter bar in Derived: void bar() {Base::bar();} • Use keyword “using” using Base::bar;

25. 4.5 Multiple Inheritance • A mechanism for deriving a class from several base classes. Ex: Student and Employee are derived classes of UniversityPerson. class Student: virtual public UniversityPerson(){. . . }; class Employee:virtual public UniversityPerson(){…}; class StudentEmployee : public Student, public Employee{. . .};

26. Common errors (page 151) • Inheritance is private by default. A common error is to omit the keyword public, which is needed to specify public inheritance. • Objects of abstract classes can NEVER be initiated. • Constructors can never be declared virtual. • More errors defined in page 151..

27. Summary • Inheritance: a powerful way for code reuse • Virtual: Dynamic binding, binding at execution time. • Abstract: must be defined in derived classes. Abstract classes can’t be instantiated.