Inheritance

Inheritance provides the mechanism to use

the attributes and properties of a class by

an other class

“the mechanism by which one class

acquires

the properties of another class”

•Base Class (or superclass): the class

being inherited from

•Derived Class (or subclass): the class

that inherits

Parent ClassParent Class

Child Class

Base Class

Derived Class

Gen

eralization

Specializatio

n

A

B

Suppose we want a new class which should have all

the properties of class A and some its own

properties.

There two ways to do this

1. lets modify the class A and add desired functions . But this approach is not good because class A may

be using in other functions .

2. Second is copy all the code of class A and add

desired functions . This approach is not good

because sometime code of class A may not be available to us .

•The base class might be used by other part of the program and by

other programs, and we want its original behavior to remain intact for

those objects that already uses it. By deriving a new class, the original

base class remains unaffected.

•The source code of the base class may not be available to us. To use

the class, we only need its declaration in header file. Though we can

not access the code, but we can use it by inheritance.

•The base class might define a component in a class library that

supports a wide community of users. So, we must not modify the base

class even if we can.

•The base class may be an abstract base class, which is a class

designed to be a base class only. A class hierarchy can contain

general-purpose classes that do nothing on their own. Their purpose is

to define the behavior of a generic data structure to which derived

classes and implementation details.

•We might be building a class hierarchy to derive the benefits of the

object-oriented approach.

When a class inherits from another class, there are three benefits:

(1) You can reuse the methods and data of the existing class(2) You can extend the existing class by adding new data and new methods(3) You can modify the existing class by overloading its methods with your own implementations

There are two classification schemes:

Classification A: There are three types of inheritance:

•Public Inheritance – it is the most common to use.

•Private Inheritance – used for terminating inheritance

chain.•Protected Inheritance

Classification B: There are five types of inheritance:

•Simple Inheritance

•Multilevel Inheritance

•Multiple Inheritance

•Hybrid Inheritance•Hierarchical Inheritance

Access

specifier

Access from

own class

Access

from

derived

class

Access in

remaining

program

Private

X X

Protected X

Public

Base class member access specifier

Type of inheritance

public

inheritance protected

inheritance private

inheritance

Public

public in derived class.

Can be accessed directly by any

non-static member functions,

friend functions and non-

member functions.

protected in derived class.

Can be accessed directly by all

non-static member functions

and friend functions.

private in derived class.




Protected









private in derived class.




Private

Hidden in derived class.

Can be accessed by non-static

member functions and friend

functions through public or

protected member functions

of the base class.






of the base class.






of the base class.

CLASSIFICATION B

•

•

•

•

•

SIMPLE INHERITANCE

In this inheritance, a derived class is created from a

single base class.

Class A

Class B

Simple inheritance

HIERARCHICAL INHERITANCE

In this type of inheritance multiple derived classes inherit

from a single base class.

A

B C D

MULTILEVEL INHERITANCE:

Class A derives class B, class B derives class C and so on. It is called

multi-level inheritance. For multi-level inheritance to be meaningful:

Data members should be protected.

Public inheritance should be used.

A

C

B

MULTIPLE INHERITANCE:

A class can be derived by more than one

classes, its called multiple inheritance.

A

C

B

HYBRID INHERITANCE:It is a combination of hierarchical and multilevel inheritance.

A

D

B C

ALLOCATION IN MEMORY

•

Data members of

base class

Data members of

derived class

base member1

base member2

...

derived member1

derived member2

...

CONSTRUCTORA constructor is a member function of a class that is

automatically called as soon as the object is created. It is used

to:

•Initialize the member data of the object.

•To dynamically and automatically allocate memory.

Following are the main properties of the constructor:

1. The constructor has the same name as that of class ( case

sensitivity is there).

2. It does not have any return type.

3. A constructor can be overloaded, i.e., there can be more

than one constructor in the class.

4. Default arguments can be used in constructor.

5. It must be public type.

DESTRUCTOR

Destructor is a special class function which destroys the object as

soon as the scope of the object ends.

An example :

Class A

{

A() { cout << “Constructor called”;}

~A(){ cout<< “Destructor called”;}

};

int main ()

{ A obj 1; // Constructor called

int x=1

if (x)

{

A obj 2; //Constructor called

} // Destructor called for obj 2

CALLING OF CONSTRUCTORS AND DESTRUCTORS IN INHERITANCE

When the object of the derived class is

instantiated, following is the sequence:

•The space for member data of the object is

allocated.

•The constructor of derived class is called (but

body is not executed)

•The constructor of base class is called and its

body is also executed.

•The body of derived class constructor is executed.

•The execution return to the function.

•Scope of derived class object goes out,

destructor of derived is called and executed.

•Destructor of base is executed.

•Space for the object is released.

DCounter class derived from Counter

class DCounter : public Counter {

public:

DCounter(int c = 0) : Counter(c)

//explicit call to the parameterized constructor of base class{ }

//decrement function

DCounter operator--( ) {

DCounter temp;

temp.count = --count ;

return temp ;

}

}; //DCounter class

int main( ){

Counter c(100);

DCounter dc(500);

++c; c.display( );

++dc; dc.display( );

--dc; dc.display();

return 0;

}

OVERRIDING OF A BASE CLASS FUNCTION IN DERIVED CLASS

The derived class may have a function with same name as that

in the base class. When the function is called with the object of

base class, the base class function is called. When the function is

called with the object of derived class, the derived class function

is called.

s1.display( ); //call to display( ) of base class

s2.display( ); //call to display( ) of derived class

TYPES OF AMBIGUITY

I) Multiple Occurrence of Same Function:

There are two classes A and B, both

have same function f( ). A class C is

derived from both the classes. When an

object of c is created and function

f( ) is called with this object, it will be

an ambiguity. A compiler will unable

to decide which f( ) is called , f( ) of

A or f( ) of B.

TYPES OF AMBIGUITY

II) Diamond Shape Ambiguity (Hybrid Inheritance Ambiguity):

There is a class A. It derives two classes B and C. Class A

contains a function f(). A class D is derived from B and C

both. When an object of D is created and the function f( )

is called with the object of D, it will be an ambiguous call,

because the compiler doesn’t know, which function f( ) to

call, through class B or through class C.

A

B

D

C

CONTAINERSHIP OR COMPOSITION

There are two classes A and B. Class B contains object of

class A as a data member. It is called containership.

Containership is also called “has a“ relationship or “ is-part-

of “ relationship.

Ex. class A {

:

};

class B {

protected :

A aobj ; //containership

public:

:

:

}

Engineering

Inheritance