Another Way to Define A Class: Inheritance

Inheritance Concept
Polygon
class Rectangle{ private: int width, length; public: void set(int w, int l); int area(); } class Triangle{ private: int width, length; public: void set(int w, int l); int area(); }

Rectangle

Triangle

class Polygon { private: int width, length; public: void set(int w, int l); }

Inheritance Concept
Polygon
class Polygon { protected: int width, length; public: void set(int w, int l); } class Rectangle{ protected: int width, length; public: void set(int w, int l); int area(); }

Rectangle

Triangle

class Rectangle : public Polygon { public: int area(); }

Inheritance Concept
Polygon
class Polygon { protected: int width, length; public: void set(int w, int l); } class Triangle{ protected: int width, length; public: void set(int w, int l); int area(); }

Rectangle

Triangle

class Triangle : public Polygon { public: int area(); }

Why Inheritance?
Reusability--building new components by utilising

existing components- is yet another important aspect of OO paradigm. It is always good/productive if we are able to reuse something that is already exists rather than creating the same all over again. Save time & money

Cond.
This mechanism of deriving a

new class from existing/old class is called inheritance. The old class is known as base class, super class or parent class; and the new class is known as sub class, derived class, or child class.

Parent
Inherited Capability

Child

Inheritance Concepts
Inheritance creates a hierarchy of related classes

(types) which share code and interface. This is also called a is a relationship:
A car is a vehicle
A dog is an animal

A teacher is a person

Inheritance Examples
Base Class Student Shape Derived Classes CommuterStudent ResidentStudent Circle Triangle Rectangle CarLoan HomeImprovementLoan MortgageLoan

Loan

Shape class hierarchy

Shape

TwoDimensionalShape

ThreeDimensionalShape

Circle

Square

Triangle

Sphere

Cube

Tetrahedron

What to inherit?
In principle, every member of a base class (data

+ member function) is inherited by a derived class

just with different access permission

However, there are exceptions for

base class's constructor and destructor base class's friends

Since all these functions are class-specific

What a derived class can add?

New data members

New member functions (also overwrite existing ones)

New constructors and destructor New friends

Generialization
In UML, inheritance is called generalization

Parent class is more general form of the child class Or

Child is more specific version of the parent

Defining Derived Classes

Defined by specifying the relationship with the

base class in addition to its own details.

Class derived-class : visibility mode base-class { . . //members of derived class };

Accessing Base Class Members

Member of base class used by derived class

object called as accessibility.

Protected: is accessible by the member functions

within its class and any class immediately derived from it.

Inheritance & Accessibility

Access Specifier public protected private Accessible from From derived own class class yes Yes yes yes yes no Form objects outside class yes no no

Overriding member functions

To override a base-class member function
In derived class, supply new version of that function
Same function name, different definition

The scope-resolution operator may be used to access the

base class version from the derived class

Access Control Over the Members

Two levels of access control

base class/ superclass/ parent class

members goes to

over class members

class definition Visibility mode
class Point{ protected: int x, y; public: void set(int a, int b); } class Circle : public Point{ }

derived class/ subclass/ child class

derive from

Visibility mode
Private (default)

Public

Examples:

Class A : private X { //members of A };

Class A: public X { //members of A };

This is an example of Single inheritance.

Public Inheritance
class A : public B { // Class A now inherits the members of Class B
} // with no change in the access specifier for // the inherited members

public base class (B) public members protected members private members

derived class (A) public protected

not inherited

Private Inheritance
class A : private B { // Class A now inherits the members of Class B // with public and protected members } // promoted to private
private base class (B) public members protected members private members
derived class (A) private private not inherited

Protected visibility
When a protected member is inherited in public

mode, it becomes protected in derived class. It is ready for further inheritance A Protected member, inherited in private mode, it becomes private in the derived class. But not further inherited.

Protected Inheritance
class A : protected B { // Class A now inherits the members of Class B // with public members promoted to protected } // but no other changes to the inherited members

protected base class (B) public members protected members private members

derived class (A) protected protected not inherited

Visibility of inherited members

Derived Class Visibility Base Class Visibility

private private protected public Not inher. private private

protected Protected protected

public protected public

Not inher. Not inher.

#include <iostream.h> class B { int a; public: int b; void get_ab(); int get_a(); void show_a(); }; class D: public B { int c; public: void mul(); void display(); };

void B::get_ab() { a=5; b=10; } int B::get_a() { return a; } void B::show_a() { cout<<"a="<<a<<endl; } void D::mul() { c=b*get_a(); } void D:: display() { cout <<"a="<<get_a()<<endl; cout<<"b="<<b<<endl; cout<<"c="<<c<<endl; }

void main() { D d; d.get_ab(); d. mul(); d.show_a(); d.display(); d.b =20; d.mul(); d.display(); } a=5 b=20 c=100 Output a=5 a=5 b=10 c=50

Forms of Inheritance:
The different forms of inheritance are:
Single inheritance (only one super class) Multiple inheritance (several super classes) Hierarchical inheritance (one super class, many sub

classes) Multi-Level inheritance (derived from a derived class) Hybrid inheritance (more than two types)

(a) Single Inheritance A

(b) Multiple Inheritance A B c

(c) Hierarchical Inheritance A c

B C (d) Multilevel Inheritance

D (e) Hybrid Inheritance

D (f) Multipath Inheritance

Multilevel Inheritance
Class A { .. }; Class B: public A { . }; Class C : public B { .. .. };

 Class B-----intermediate class Chain ABC is known as inheritance path Process can be extended to any number of

levels.

Multiple Inheritance
A class can inherit the attributes of two or more classes.
A B C Class D: public A, public B { ----- } D

 Combines the features of several existing classes

to define a new class.

Child inheriting the smartness from his mother &

intelligence from father..

Ambiguity Resolution in inheritance

When a function with the same name appears in

more than one base class. We can solve this problem by defining a named instance within the derived class, using the scope resolution operator with the function

Ambiguity in single inheritance applications

Class A { Public: Void display() { Cout<<A; } };
Class B:public A { Public: Void display() { Cout<<B; } }; Void main() { B b; b.display(); b.A::display(); }

Hierarchical Inheritance
Class A { .. }; Class B:public A { .. .. }; Class C:public A { . };

Hybrid Inheritance
There could be situations where we need to apply two or

more types of inheritance to design a program. For example

Student Sports

test

Result

Multilevel Multiple

Virtual Base Classes

The duplication of inherited members due to multiple

paths can be avoided by making the common base class as virtual base class. Class A { . }; Class B1:virtual public A { };

Class B2:public virtual A { }; Class C:public B1,public B2 { . };

Abstract Classes
An abstract class is one that is not used to create

objects. It is designed only to act as a base class.

Constructors in Derived class

No parameterized constructor in base class: no

need to define constructor in derived class. If contains then there is a need to define ctor in derived class. Usually we create objects of derived classes, it make sense to pass arguments to the base class constructor. If both classes are having constructors, then the base constructor is executed first and then the constructor in the derived class is executed.

General Syntax
Derived-ctor (Arg1, n(argn)arg2,argn, argd): base1(arg1),base2(arg2),.basen(argn) { //body of derived constructor } D(int a1, int a2, int d1):B(a1,a2) { d=d1; }

Using Constructors and Destructors in Derived Classes

Derived-class constructor
Calls the constructor for its base class first to initialize its

base-class members If the derived-class constructor is omitted, its default constructor calls the base-class default constructor

Destructors are called in the reverse order of

constructor calls.
Derived-class destructor is called before its base-class

destructor

Example 1:default in base no need of

ctor in derived
Class A { int a; public: A(){a=0;} void display() {cout<<a;} }; class B

{ public: void display() {A::display();} }; void main() {B b1; b1.display(); }

Output is: 0

Example 2:if default ctor in derived

Class A { int a; public: A(){a=0;} void display() {cout<<a;} }; class B

{int b; public: B(){b=5;} void display() {A::display(); cout<<b;}}; void main() {B b1; b1.display(); }

Output is: 05

Example 3
Class A { int a; public: A(){a=0;} A(int m) {a=m;} void display() {cout<<a;} }; class B
{int b; public: B(){b=5;} void display() {A::display(); cout<<b;}}; void main() {B b1; b1.display(); }

Output: 05

Example 4
Class A { int a; public: A(){a=0;} A(int m) {a=m;} void display() {cout<<a;} }; class B

{int b; Output is: 0 10 public: B(){b=5;} B(int n){b=n;} void display(){A::display(); cout<<b;}};
void main() {B b1(10); b1.display();

Example 5
Class A { int a; public: A(){a=0;} A(int m) {a=m;} void display() {cout<<a;} }; class B {int b; public: B(){b=5;} B(int m,int n):A(m),b(n){} void display(){A::display(); cout<<b;}}; void main() {B b1(10,20); b1.display(); }

Multiple Inheritance with constructors

Base classes are constructed in the order in

which they appear in the declaration of the derived class.

Example

Class D:public A, protected B, private C Order of execution is: A B C D

Multilevel Inheritance with constructors

In multilevel inheritance, the constructors will be

executed in the order of inheritance.

A Order is B A B C

Execution of base class constructors

Constructors for virtual base classes are invoked before any non-virtual base classes. Class A:public virtual B, public C, public D Class A:public B, virtual public C, public D Class A:virtual public B, public C, virtual public D

class A { int a; public: A(int x) {a=x;} void show() {cout<<a;} }; class B {int b; public: B(int y) {b=y; }

void show() void main() { { cout<<b; C c1(4,5,6); }}; c1.A::show(); class C:public A, public B c1.B::show(); { c1.show(); int c; } public: C(int m, int n, int z):B(n),A(m),C(z) {cout<<objects initialized;} void show() {cout<<c;} };

Case Study: Point, Circle, Cylinder

Define class Point
Derive Circle
Derive Cylinder