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

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

CONSTRUCTOR
A 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:
:
:
}

Inheritance

More Related Content

What's hot

Viewers also liked

Similar to Inheritance

Recently uploaded

Inheritance