Chapter 4 Inheritance

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 C++ stuff

4.1 What is Inheritance? Another mechanism for code reuse. A process of deriving classes from a base class without disturbing the implementation of the base class. Inheritance models the IS-A relationship. In a is-a relationship the derived class is a variation of the base class. Ex: Vehicle is a class Car is a Vehicle => Car derived from Vehicle

Inheritance Concept A key feature of C++ classes is inheritance. Inheritance allows to create classes which are derived from other classes, so that they automatically include some of its "parent's" members, plus its own. For example, we are going to suppose that we want to declare a series of classes that describe polygons like our CRectangle, or like CTriangle. They have certain common properties, such as both can be described by means of only two sides: height and base. This could be represented in the world of classes with a class CPolygon from which we would derive the two other ones: CRectangle and CTriangle.

Inheritance Concept Polygon Rectangle Triangle class Rectangle{ private: int numVertices; float *xCoord, *yCoord; public: void set(float *x, float *y, int nV); float area(); }; Polygon Rectangle Triangle class Polygon{ private: int numVertices; float *xCoord, *yCoord; public: void set(float *x, float *y, int nV); }; class Triangle{ private: int numVertices; float *xCoord, *yCoord; public: void set(float *x, float *y, int nV); float area();}; Ref: http://www.cse.ohio-state.edu/~neelam/courses/45922/

Inheritance Concept Polygon Rectangle Triangle class Polygon{ protected: int numVertices; float *xCoord, float *yCoord; public: void set(float *x, float *y, int nV); }; Polygon Rectangle Triangle class Rectangle{ protected: int numVertices; float *xCoord, float *yCoord; public: void set(float *x, float *y, int nV); float area();}; class Rectangle : public Polygon{ public: float area(); };

Inheritance Concept Polygon Rectangle Triangle class Polygon{ protected: int numVertices; float *xCoord, float *yCoord; public: void set(float *x, float *y, int nV); }; Polygon Rectangle Triangle class Triangle{ protected: int numVertices; float *xCoord, float *yCoord; public: void set(float *x, float *y, int nV); float area();}; class Triangle : public Polygon{ public: float area(); };

Figure 4.2 istringstream istream fstream ifstream IOS iostream ostringstream ofstream

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. Syntax: class DerivedClassName : access-level BaseClassName

General layout of public inheritance class Derived: public Base{ // any members that are not listed are inherited unchanged //except for constructor, destructor, copy constructor, and //operator = public: //constructors, and destructors if defaults are not good // Base members whose definitions are to change in Derived // Additional public member functions private: //Additional data members(generally private) // Additional private member functions // Base members that should be disabled in Derived };

Inheritance 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.

Access Rules Public Inheritance Situation Public Protected Private Base class member function accessing M Yes Derived class member function accessing M No Main, accessing B.M Main, accessing D.M Derived class member function accessing B.M Note: B is an object of the base class; D is an object of the publicly derived class; M is member of the base class.

Constructor and Base class initialization Constructors should be defined for each derived class. If there is no constructor in a derived class, a default zero-parameter constructor will be generated which in turn calls the zero-parameter constructor in the base class to initialize the inherited members Derived() : Base() { }

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.

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

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. If a function is redefined in a derived class, it should be declared virtual in the base class. Example: class Worker{ public: virtual void doWork(); };

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

Polymorphism Static and dynamic binding In most programming languages and in most cases the variables are bound to a specific type at compile time Static binding Dynamic binding The type of the variable can change at run time Using pointers to classes related by inheritance in C++ In C we can use unions to allow dynamic binding of arbitrary types Dangerous in some cases Ref: www.cs.uh.edu/~mirkovic/cosc1305/

Polymorphism Polymorphism, many forms, using the same name for “many different things.” Polymorphism is the ability of a reference variable to reference objects of several different types. When operations are applied to the variable, the operation that is appropriate to the actual reference 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.

C++ Polymorphism Definition: Single name denotes objects of different classes related by inheritance Ability to manipulate derived objects using the interface defined in the base class Example: class Employee { public: void CalcPay (); }; class SalariedEmployee :public Employee{

Example Which function is called? Employee *ep; ep = new SalariedEmployee; Ep->CalcPay(); Which function is called? The function in Employee is called To avoid that we have to declare CalcPay() as a virtual function

Virtual Functions Definition: Example: Nonstatic member function prefaced by the virtual specifier. Compiler generates the code that will select the appropriate function at runtime Example: class Employee { public: virtual void CalcPay (); }; class SalariedEmployee :public Employee{ virtual specifier needs to appear in the base class only.

Examples Employee *p0 = new Employee; Employee *p1 = new SalariedEmployee; p0->CalcPay(); // calls Employee::CalcPay() p1->CalcPay(); // calls SalariedEmployee::CalcPay() Any nonstatic member function except a constructor can be virtual Virtual functions can also be friends of other classes Some compilers require the class destructor to be virtual if a class contains any virtual functions

C++ Virtual Function   C++ virtual function is a member function of a class, whose functionality can be over-ridden in its derived classes. The whole function body can be replaced with a new set of implementation in the derived class.

Properties of Virtual Functions The main difference between a non-virtual C++ member function and a virtual member function is in the way they are both resolved. A non-virtual C++ member function is resolved during compile time or static binding. Virtual Functions are resolved during run-time or dynamic binding Virtual functions are member functions of a class. Virtual functions are declared with the keyword virtual. Virtual function takes a different functionality in the derived class.

v - table Whenever a program has a virtual function declared, a v-table is constructed for the class. The v-table consists of addresses to the virtual functions for classes that contain one or more virtual functions.

Virtual A constructor cannot be virtual because at the time when the constructor is invoked the virtual table would not be available in the memory. Hence we cannot have a virtual constructor. Destructors should be virtual for base class => Let the computer know which one to call for deallocation.

virtual destructor A virtual destructor is one that is declared as virtual in the base class and is used to ensure that destructors are called in the proper order. It is to be remembered that destructors are called in the reverse order of inheritance. If a base class pointer points to a derived class object and we some time later use the delete operator to delete the object, then the derived class destructor is not called.

In this case the type of the pointer would be considered. #include <iostream.h> class base {    public:    ~base()   {   } }; class derived : public base {    public:    ~derived()    {      } }; void main() {    base *ptr = new derived();    // some code    delete ptr; } In this case the type of the pointer would be considered. Hence as the pointer is of type base, the base class destructor would be called but the derived class destructor would not be called at all. The result is memory leak. In order to avoid this, we have to make the destructor virtual in the base class.

#include <iostream #include <iostream.h> class base { public: virtual ~base() { } }; class derived : public base {    public:    ~derived()    {    } }; void main() {    base *ptr = new derived();    // some code    delete ptr; } no memory leak here.

General rules Nonvirtual functions: Overloading is resolved at compile time. Virtual functions: Overloading is resolved at run-time Pure virtual functions Overloading is resolved at run-time.

Abstract Abstract method: A 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 NOT be instantiated and must be inherited. Example: shape class

Figure 4.13 The abstract base 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; };

4.3 Examples: Expanding the Shape class Provide new constructors Write definition for inherited pure virtual functions. Shape.cpp Example: Shape *a, *b; a= new Circle (3, 0) //legal b= new Shape (“circle”) //illegal

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. 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

class Base{ public: virtual void bar(); }; class Derived{ 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 existing => OK arg2.bar(4); // call Derived::bar(int) => OK arg2.bar(); // fails b/c Derived::bar(int) has hidden Base::bar() } Get away by define one of the following two void bar(){Base::bar();} // in Derived class using Base::bar; // new std, may not be accepted by some compilers

Inheritance Cont . . An inherited method can be overridden required that the new method must have exact signature and the return type must be the same or of a derived type from the base class. Default inheritance is private. Try to avoid it. Friend functions of a base class are not friends of the derived ones. Slicing: casting a derived class to its base will surrender data defined in the derived class.

//: C15:Slice.cpp // Object slicing #include <iostream> using namespace std; class Base { int i; public: Base(int ii = 0) : i(ii) {} virtual int sum() const { return i; } }; class Derived : public Base { int j; public: Derived(int ii = 0, int jj = 0) : Base(ii), j(jj) {} int sum() const { return Base::sum() + j; } }; void call(Base b) { cout << "sum = " << b.sum() << endl; } int main() { Base b(10); Derived d(10, 47); call(b); call(d); } ///:~

Slicing The function call( ) is passed an object of type Base by value . It then calls the virtual function sum( ) for the Base object. Two things are happening in this program. First, call( ) accepts only a Base object, so all the code inside the function body will manipulate only members associated with Base. Any calls to call( ) will cause an object the size of Base to be pushed on the stack and cleaned up after the call. This means that if an object of a class inherited from Base is passed to call( ), the compiler accepts it, but it copies only the Base portion of the object. It slices the derived portion off of the object, like this:

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{. . .}; Virtual inheritance prevents duplicate data members inherited from base classes.

What a derived class inherits Every data member defined in the parent class (although such members may not always be accessible in the derived class!) Every ordinary member function of the parent class (although such members may not always be accessible in the derived class!) The same initial data layout as the base class What a derived class doesn't inherit The base class's constructors and destructor The base class's assignment operator The base class's friends

What happens when a derived-class object is created and destroyed 1. Space is allocated (on the stack or the heap) for the full object (that is, enough space to store the data members¤¤ inherited from the base class plus the data members defined in the derived class itself) 2. The base class's constructor is called to initialize the data members inherited from the base class 3. The derived class's constructor is then called to initialize the data members¤¤ added in the derived class 4. The derived-class object is then usable 5. When the object is destroyed (goes out of scope or is deleted) the derived class's destructor is called on the object first 6. Then the base class's destructor¤ is called on the object 7. Finally the allocated space for the full object is reclaimed http://burks.bton.ac.uk/burks/language/cpp/cppfaq/privatei.htm

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. More errors defined in page 151

Three Types of Inheritance Access level of members will be changed by derivation. (private parts will always be invisible in derived class.) “public” inheritance Base Derived private (invisible) protected protected public public “private” inheritance protected private public private “protected” inheritance public protected protected, public parts will be unchanged (struct’s default) protected, public parts will be private (class’s default) protected, public parts will be protected

In class exercises When should a constructor be virtual? When should a destructor be virtual? Explain the rules when to use virtual and non-virtual functions.

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. Friendship is not inheritable.

Homework Hw 2: 3.4, 4.5, due on next wed. Finish reading chapter 4 and preview chapter 6