INHERITANCE

DEFINATION

Inheritance is a mechanism of creating new classes called derived class from existing ones i.e. base classes.

Inheritance is a most powerful feature of object oriented programming.

Types of Inheritance

Single Inheritance Multiple Inheritance Multilevel Inheritance Hierarchical Inheritance Hybrid Inheritance

SINGLE INHERITANCE

When a derived class inherits only from one base class ,it is Known as single Inheritance.

Base Class

Derived Class

A

B

When a derived class inherit from multiple base classes it is known as multiple Inheritance.

A B

C

MULTIPLE INHERITANCE

Base Class

Derived Class

MULTILEVEL INHERITANCE

When a derived class inherit from a class that itself inherits from other class , it is known as multilevel Inheritance.

Base Class

Derived Class of x Base Class of z

Derived Class

A

B

C

HYBRID INHERITANCE

Hybrid Inheritance combines two or more forms of Inheritance.

w

x y

z

HIERARCHICAL INHERITANCE When many derived classes inherit from a

single base class , it is known as hierarchical Inheritance.

Base Class

Derived classes

a

b c d

A general form to defining a derived class is:

Class derived class name: visibility mode base class name{ members of derived class} ;

Class ABC: public XYZ{ members of ABC};

DEFINING DERIVED CLASS

Example of derived class definition is:

Class Sub : public Super \\ public derivation{ ……… \\ members of sub};

Class Sub: private Super \\ private derivation{……... \\ members of sub};

Class Sub: protected Super \\ protected derivation{……... \\ members of sub};

MULTIPLE INHERITANCEExample of derived class definition is:

Class derived_class : vis_mode base1, vis_mode base 2{…………. \\ members of derived class};

Class Sub : public SuperA, private SuperB{ ……… \\ members of sub};

Visibility Modes

DEFINATION:- Visibility Mode specifies whether the features

of the base class are privately derived or publicly derived or protected derived.

Public Visibility Mode- It means that the derived class can access the public and protected members of the base class. The public members of the base class become the public member of the derived class, and the protected member of the base class become the protected member of the derived class.

Private Visibility Mode- The public and protected members of the base class become private members of the derived class. The inherited members can only be accessed only through the member function of derived class.

Protected Visibility Mode- The public and protected members of base class become protected members of the derived class.

Visibility of Inherited base class members in Derived Class.

Visibility Visibility ModeMode

Public Public members members of base of base class class becomesbecomes

Protected Protected members members of base of base class class becomesbecomes

Private Private members members of the of the base class base class is not is not accessible accessible to the to the derived derived class.class.

PublicPublic PublicPublic ProtectedProtected

ProtectedProtected ProtectedProtected ProtectedProtected

PrivatePrivate PrivatePrivate PrivatePrivate

Accessibility of Base class members Access Specifier

Accessible from own class

Accessible from derived class

Accessible from objects outside class

Public Yes Yes Yes

Protected Yes Yes No

Private Yes No No

Inheritance and Constructors and Destructors

When an object of a derived class is created, the program first calls the constructor for base class.

When an object expires, the program first calls the derived destructor and then base destructor

Class super

{

…….

};

Class Sub : public Super

{ …..

};

int main()

{

sub ob1;

…….

}

Base class ConstructorsBase class constructor require arguments to construct their objects.

It is the responsibility of derived class constructor to pass those arguments to base class.

Syntax :

Derived ::Derived (type1 x, type2 y ….) : base (x , y)

{

…..

}

Class Base

{ int a;

float b;

public :

Base(int I, float j)

{ a = i;

b = j;

}

…

};

Class Derived : public Base

{….

Public :

Derived ( int p, float q) : Base (p , q)

{ }

};

Even if derived const does not need a parameter, yet it accepts parameter for base const.

Class Base

{ int a;

float b;

public :

Base( int i, float j)

{ a = i;

b = j;

}

…

};

Class Derived : public Base

{ int x; float y;

Public :

Derived ( int i, int j , int p, float q) : Base (p , q)

{ x = i ;

Y = j ;

}

};

Derived Const is accepting parameter for itself( i ,j) and ( p , q) for Base const

Constructor in Derived Class

# include<iostream.h> class alpha{

protected: int x;

alpha(int i){ x=i;}}; class beta{

protected: float y;

Beta(float j){

y=j;}};

Class gamma: public beta, public alpha{

int k;public:

gamma(int a,float b, int c): alpha(a) , beta(b){

k=c;}void show(){

cout<<“1”<<x<<“2”<<y<<“3”<<k;}};

void main(){

gamma g(14,15.2,17);

g.show();

}

Facts about inheritance Private members of a base class are not directly accessible in the derived class.

Example

int test; \\ Global variable

Class base { int test; \\ private members of base

public:

void getit()

{ cin>> test;

}

};

Class derived : public base

{ public :

void check ( )

{ test++; } \\ not allowed

};

When a class is derived publicly, you cannot selectively deny access to base members by declaring them in derived private section of the derived class.

Example

Class base {

Public :

int x,y,z;

};

Class derived : public base

{

Public:

int a;

Private :

Base :: x; // Invalid

}

When you derive a class privately, you can selectively allow access to some of the base members. To allow access to some of the inherited members, you can selectively declare some of the base class members in the public section of the privately derived class.

Example Class base {Public :int x,y,z;};Class derived : private base { Public:int a;Base :: x; \\Valid}

Or

Public :

Using Base :: x ;

Abstract class

A class that serves only as a base class from which other classes can be derived, but no objects of this base type exist, is known as abstract class.

Constructors in Multiple inheritance As long as no base class constructor takes any arguments, the derived class need not have a constructor function. However, if a base class contains a constructor with one or more arguments, then it is mandatory for the derived class to have a constructor and pass the arguments to the base constructor.

In multiple inheritance , the base classes are constructed in the order in which they appear in the declaration of the derived class.

Example

Class Base1

{ protected :

int a;

public :

Base1(int x)

{ a = x; cout<<“Constructing Base 1”; }

~Base1( )

{ cout<<“Destructing Base1”; }

};

Class base2

{ Protected :

int b;

public :

Base2(int y)

{ b = y; cout<<“Constructing Base2”; }

~Base2 ( )

{ cout<< Destructing Base2 “; }

};

Class derived : public Base2, public Base1

{ int c;

public :

derived (int I, int j, int k): Base2(i), Base1(j)

{ c = k; cout <<“Constructing Derived”; }

~ Derived ( ){ cout << Destructing Derived “; }Void show( ){ cout <<“1.”<<a<<“\t 2.”<<b <<“\t 3.”<<c; }};Int main ( ){ Clrscr();Derived ob(14,15,16);Ob.show();}

OUTPUT :Constructing Base2Constructing Base1Constructing Derived1. 15 2. 14 3. 16Destructing Derived Destructing Base1Destructing Base2

Virtual Base classExample Class Base { public : int a ;};Class D1 : public Base \\ D1 inherits Base{ public :

int b ;};Class D2 : public Base \\ D2 inherits Base{ public :

int c ;};Class D3 : public D1, public D2 \\ D3 inherits D1 and D2{ public :

int total;};Void main ( ){ D3 ob;ob.a = 25 \\ this is ambiguousOb.b = 50;Ob.c = 75;Ob.total = ob.a +ob.b + ob.c;Cout <<ob.a<<“\t”<< ob.b<<“\t”<< ob.c<<“\t”<< ob.total<<“\t”<<“\n”;}

To Use Scope resolution operator to a

Void main ( ){ D3 ob;ob.D1 :: a = 25 \\ scope resolvedOb.b = 50;Ob.c = 75;Ob.total = ob.D1 :: a +ob.b + ob.c;Cout <<ob.D1 :: a<<“\t”<< ob.b<<“\t”<< ob.c<<“\t”<< ob.total<<“\t”<<“\n”;}

Remedy

To Use a keyword Virtual

Example

Class Base { public : int a ;};Class D1 : virtual public Base \\ D1 inherits Base as Virtual { public :

int b ;};Class D2 : virtual public Base { public :

int c ;};Class D3 : public D1, public D2 \\ this time only one copy of base{ public :

int total;};

Void main ( ){ D3 ob;ob.a = 25 \\ now unambiguousOb.b = 50;Ob.c = 75;Ob.total = ob.a +ob.b + ob.c;Cout <<ob.a<<“\t”<< ob.b<<“\t”<< ob.c<<“\t”<< ob.total<<“\t”<<“\n”;}

Example of Multilevel Inheritance

#include<iostream.h> class student { protected: int roll_number; public: void get_number() { cout<<"Enter rollno"; cin>>roll_number; } void putnumber() { cout<<roll_number; } };

class test: public student{

protected: float sub1; float sub2; public: void getmarks() { cout<<"enter the marks of sub1,sub2"; cin>>sub1>>sub2; } void putmarks() { cout<<"marks in sub1="<<sub1; cout<<"marks in sub2="<<sub2; }

};

class result : public test{ float total; public: void display(void) { total=sub1+sub2; putnumber(); putmarks(); cout<<"Total"<<total; } }; void main() { result a; a.get_number(); a.getmarks(); a.display(); }

ANY QUERY

THANK YOU