Chapter 4Inheritance

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.

class Rectangle{

private:

int numVertices;

float *xCoord, *yCoord;

public:

void set(float *x, float *y, int nV);

float area();

};

Inheritance Concept

Rectangle Triangle

Polygon

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/

Rectangle Triangle

Polygonclass Polygon{

protected:

int numVertices;

float *xCoord, float *yCoord;

public:

void set(float *x, float *y, int nV);

};

class Rectangle : public Polygon{

public:

float area();

};

class Rectangle{

protected:

int numVertices;

float *xCoord, float *yCoord;

public:

void set(float *x, float *y, int nV);

float area();};

Inheritance Concept

Rectangle Triangle

Polygonclass Polygon{

protected:

int numVertices;

float *xCoord, float *yCoord;

public:

void set(float *x, float *y, int nV);

};

class Triangle : public Polygon{

public:

float area();

};

class Triangle{

protected:

int numVertices;

float *xCoord, float *yCoord;

public:

void set(float *x, float *y, int nV);

float area();};

Inheritance Concept

Figure 4.2

IOS

istream

ostream

iostream

ifstream

istringstream

ostringstream

ofstream

fstream

stringstream

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

Derived class member function accessing M

Yes Yes No

Main, accessing B.M Yes No No

Main, accessing D.M Yes No No

Derived class member function accessing B.M

Yes No No

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 membersDerived() : 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 overridingclass Workaholic : public Worker{

public: void doWork(){ // overriding base method

Worker::doWork();// call base methoddrinkCoffee(); // new methodWorker::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 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

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{ public:

void CalcPay ();};

Example

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: 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{ public:

virtual void CalcPay ();};

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.

#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.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 shapeclass 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) //legalb= 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{

public:void bar(int x);

};Void test( Base & arg1, Derived & arg2){

arg1.bar(); // call Base::bar() => OKarg1.bar(4); //call Base::bar(int) => fails for not existing => OKarg2.bar(4); // call Derived::bar(int) => OKarg2.bar(); // fails b/c Derived::bar(int) has hidden Base::bar()

}

Get away by define one of the following twovoid bar(){Base::bar();} // in Derived classusing 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

- “public” inheritanceBase Derivedprivate (invisible)protected protectedpublic public

- “private” inheritanceBase Derivedprivate (invisible)protected privatepublic private

- “protected” inheritanceBase Derivedprivate (invisible)protected protectedpublic 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

Access level of memberswill be changed by derivation.(private parts will always be invisible in derived class.)

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