Unit 4: Inheritance (12)
4.1
Concept of inheritance
4.2
Base and Derived class
4.3
private, Public and Protected specifier
4.4
Derived class declaration
4.5
Member function overriding
4.6
Single, Multiple, Multilevel and Hybrid Inheritance
4.7
Ambiguity Problems in inheritance
4.8
Constructor in derived class
4.9
Extending operator overloading in derived class
Practical Works:
·
Create single level Inheritance
·
Create multiple inheritance
·
Create multilevel inheritance
·
Check the ambiguity problrms
4.1 Concept of
inheritance
1. Inheritance
is a process by which new classes called derived classes are created from
existing classes called Base classes.
2. The derived
classes have all the features of the Base class and the programmer can choose
to add new features specific to the newly created derived class.
3. For example, a programmer can create a base class named fruit and define derived classes as Mango, Orange, Banana, etc each of them has some common characteristics like taste, price and season.
Sub Class: The class that inherits properties from another class is
called Sub class or Derived Class.
Super Class: The class whose properties are inherited by sub class is
called Base Class or Super class.
Advantages of inheritance:
1. Reusability: inheritance helps to reuse the
previously written code. Using the concept of inheritance, the programmer can
create as many derived classes from the base class as needed while adding
specific features to each derived class as needed.
2. Save time and effort: the concept of reusability
achieved by inheritance saves programmer time and effort.
3. Extendibility (enhancement) of the
code: without changing the base class ,
we can add some more methods and features in derived class to extend the
program. We can add any number of derived classes to upgrade the
functionalities of the program.
4.2 Base and
Derived class
Derived Class: The class that inherits properties from another class is
called Sub class or Derived Class.
Base Class: The class whose properties are inherited by sub class is
called Base Class or Super class.
Syntax:
Class
base_Class_name
{
…………..
…………
};
Class
derived_class_name : visibility_mode base_class_name
{
Code for specific features
of derived class
…………
};
Example: write a program to illustrate the use of inheritance.
|
// C++ program to demonstrate
implementation // of Inheritance #include <bits/stdc++.h> using namespace std; // Base class class Parent { public: int id_p; }; // Sub class inheriting from Base
Class(Parent) class Child : public Parent { public: int id_c; }; // main function int main() { Child obj1; // An object
of class child has all data members // and member
functions of class parent obj1.id_c =
7; obj1.id_p =
91; cout <<
"Child id is: " << obj1.id_c << '\n'; cout <<
"Parent id is: " << obj1.id_p << '\n'; return 0; } |
Output
Child id is 7
Parent id is 91
In the above program the ‘Child’ class
is publicly inherited from the ‘Parent’ class so the public data members of the
class ‘Parent’ will also be inherited by the class ‘Child’.
4.3 private, Public
and Protected specifier
Visibility Modes of Inheritance
- Public
mode: If we
derive a sub class from a public base class. Then the public member of the
base class will become public in the derived class and protected members
of the base class will become protected in derived class.
- Protected
mode: If we
derive a sub class from a Protected base class. Then both public member
and protected members of the base class will become protected in derived
class.
3.
Private
mode: If we derive a sub class from a
Private base class. Then both public member and protected members of the base
class will become Private in derived class.
Fig: visibility modes and its effects on inheritance
Note: The private
members in the base class cannot be directly accessed in the derived class,
while protected members can be directly accessed. For example, Classes B, C and
D all contain the variables x, y and z in below example. It is just question of
access.
|
// C++ Implementation to show that a
derived class // doesn’t inherit access to private
data members. // However, it does inherit a full
parent object. class A { public: int x; protected: int y; private: int z; }; class B : public A { // x is
public // y is protected // z is not
accessible from B }; class C : protected A { // x is
protected // y is
protected // z is not
accessible from C }; class D : private A // 'private' is
default for classes { // x is
private // y is private // z is not
accessible from D }; |
4.4. Derived class
declaration
1. in the declaration of derived class,
you list the base classes of the derived class. The derived class inherits its
members from these base classes.
2. The qualified_class_specifier must be
a class that has been previously declared in a class declaration.
3. An access specifier is one of public,
private, or protected.
4. The virtual keyword can be used to
declare virtual base classes.
5. Following example shows the
declaration of the derived class D and base classes V, B1, and B2. The class B1
is both a base class and a derived class because it is derived from class V and
is a base class for D.
Class v {/*…..*/};
Class B1 : virtual public V {/*…..*/};
class B2 {/*…..*/};
class D : public
B1, private B2 {/*…..*/};
4.5 Member function
overriding
1.
when a function, defined in the base class, is redefined in the derived class
to fit its own needs, it is called function overriding.
2.
Function overriding contains a function in the derived class which has the same
name and argument types as the function in the base class but the definition is
different.
3.
Function overriding is the use of two or more functions having same name with
same signature but defined one in base class and other in derived class.
Example: write a
program to illustrate the use of function overriding
#include<iostream.h>
#include<conio.h>
class Person
{
protected:
char name[20];
public:
void read ()
{
cout<<”enter name of person:”;
cin>>Name
}
Void Display()
{
cout<<”Name:”<<Name<<endl;
}
;
Class Student: public person
{
int Roll;
public:
void read ()
{
cout<<”enter roll of Student:”;
cin>>Roll;
}
Void Display()
{
cout<<”Roll No:”<<Roll<<endl;
};
Void main ()
{
Student st;
St.Person::Read ();
St.Read();
Cout<<:”*******your records ******”<<endl;
St.Person::Display();
St.Display();
Getch();
}
Output
Enter
Name of Person: Ram
Enter
Roll of Student:100
*********your
records******
Name:Ram
Roll
No.:100
4.6 Types of
inheritance (Single, Multiple, Multilevel, Hierarchical and Hybrid Inheritance)
1. Single Inheritance: In single inheritance, a class is allowed to inherit
from only one class. i.e. one sub class is inherited by one base class only.
Syntax:
class subclass_name : access_mode
base_class
{
// body of subclass
};
|
// C++ program to explain // Single inheritance #include<iostream> using namespace std; // base class class Vehicle { public: Vehicle() { cout
<< "This is a Vehicle\n"; } }; // sub class derived from a single
base classes class Car : public Vehicle { }; // main function int main() { // Creating
object of sub class will // invoke the
constructor of base classes Car obj; return 0; } |
Output
This is a Vehicle
2. Multiple Inheritance: Multiple Inheritance is a feature of C++ where a class
can inherit from more than one classes. i.e one sub class is inherited
from more than one base classes.
Syntax:
class subclass_name : access_mode
base_class1, access_mode base_class2, ....
{
// body of subclass
};
Here, the
number of base classes will be separated by a comma (‘, ‘) and access mode for
every base class must be specified.
|
// C++ program to explain // multiple inheritance #include<iostream> using namespace std; // first base class class Vehicle { public: Vehicle() { cout
<< "This is a Vehicle\n"; } }; // second base class class FourWheeler { public: FourWheeler() { cout
<< "This is a 4 wheeler Vehicle\n"; } }; // sub class derived from two base
classes class Car : public Vehicle, public FourWheeler { }; // main function int main() { // Creating
object of sub class will // invoke the
constructor of base classes. Car obj; return 0; } |
Output
This is a Vehicle
This is a 4 wheeler Vehicle
3.
Multilevel Inheritance: In this type of inheritance, a derived class is
created from another derived class.
|
// C++ program to implement // Multilevel Inheritance #include<iostream> using namespace std; // base class class Vehicle { public: Vehicle() { cout
<< "This is a Vehicle\n"; } }; // first sub_class derived from class
vehicle class fourWheeler: public Vehicle { public: fourWheeler() { cout
<< "Objects with 4 wheels are vehicles\n"; } }; // sub class derived from the derived
base class fourWheeler class Car: public fourWheeler { public: Car() { cout
<< "Car has 4 Wheels\n"; } }; // main function int main() { // Creating
object of sub class will // invoke the
constructor of base classes. Car obj; return 0; } |
Output
This is a Vehicle
Objects with 4 wheels are vehicles
Car has 4 Wheels
4. Hierarchical Inheritance: In this type of inheritance, more than one sub class is
inherited from a single base class. i.e. more than one derived class is created
from a single base class.
|
// C++ program to implement // Hierarchical Inheritance #include<iostream> using namespace std; // base class class Vehicle { public: Vehicle() { cout
<< "This is a Vehicle\n"; } }; // first sub class class Car: public Vehicle { }; // second sub class class Bus: public Vehicle { }; // main function int main() { // Creating
object of sub class will // invoke the
constructor of base class. Car obj1; Bus obj2; return 0; } |
Output
This is a Vehicle
This is a Vehicle
5. Hybrid (Virtual) Inheritance: Hybrid Inheritance is implemented by
combining more than one type of inheritance. For example: Combining
Hierarchical inheritance and Multiple Inheritance.
Below image shows the combination of hierarchical and multiple inheritance:
|
// C++ program for Hybrid Inheritance #include<iostream> using namespace std; // base class class Vehicle { public: Vehicle() { cout
<< "This is a Vehicle\n"; } }; //base class class Fare { public: Fare() { cout
<< "Fare of Vehicle\n"; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle, public Fare { }; // main function int main() { // Creating
object of sub class will // invoke the
constructor of base class. Bus obj2; return 0; } |
Output
This is a Vehicle
Fare of Vehicle
4.7
Ambiguity Problems in inheritance
When a function
with same name and signature is defined in base class and derived class,
problem of ambiguity arises. When the function is called with the help of
object of derived class, then the question arises: “which version of the
function is called?”. The problem is solved by using scope resolution operator
(i.e. ::). By default, derived class gives priority to the function defined
within it. So, base class version of the function is overridden by derived
class version. To call base class version using object of derived class, we use
scope resolution operator. This process is also called Ambiguity Resolution in
inheritance.
An example
program is shown below to demonstrate the concept of ambiguity resolution in
inheritance.
class Base1{
public:
void greet(){
cout<<"How are
you?"<<endl;
}
};
class Base2{
public:
void greet()
{
cout << "Kaise ho?"
<< endl;
}
};
class Derived : public Base1, public
Base2{
int a;
public:
void greet(){
Base2 :: greet();
}
};
int main(){
// Ambibuity 1
Base1 base1obj;
Base2 base2obj;
base1obj.greet();
base2obj.greet();
Derived d;
d.greet();
return 0;
}
Another example
of ambiguity resolution in inheritance is shown below.
class B{
public:
void say(){
cout<<"Hello
world"<<endl;
}
};
class D: public B{
int a;
// D's new say() method will override base class's say() method
public:
void say()
{
cout << "Hello my
beautiful people" << endl;
}
};
int main(){
// Ambibuity 2
B b;
b.say();
D d;
d.say();
return 0;
}
4.8 Constructor in
derived class
C++ program to the sequence of execution of constructor
and destructor inheritance
#include<iostream>
using namespace std;
class parent //parent class
{
public:
parent() //constructor
{
cout << "Parent class Constructor\n";
}
~parent()//destructor
{
cout << "Parent class Destructor\n";
}
};
class child : public parent//child
class
{
public:
child() //constructor
{
cout << "Child class Constructor\n";
}
~ child() //destructor
{
cout << "Child class Destructor\n";
}
};
int main()
{
//automatically executes both child and parent class
//constructors and destructors because of inheritance
child c;
return 0;
}
Another example
of ambiguity resolution in inheritance is shown below.
class B{
public:
void say(){
cout<<"Hello
world"<<endl;
}
};
class D: public B{
int a;
// D's new say() method will override base class's say() method
public:
void say()
{
cout << "Hello my
beautiful people" << endl;
}
};
Code Snippet 3: Ambiguity Resolution in Inheritance Example
Program 2
As shown in a
code snippet 3,
- We have
created a “B” class which consists of public member function “say”. The
function “say” will print “hello world”
- We have
created a “D” class that is inheriting the “B” class. The “D” class
consists of the public member function “say”. The function “say” will
print “Hello my beautiful people”
The main thing
to note here is that both “B” and “D” classes have the same function “say”, So
if the class “D” will call the function “say” it will override the base class
“say” method because compiler by default run the method which is already
written in its own body. But if the function “say” was not present in the class
“D” then the compiler will run the method of the class “B”.
The code of the
main function is shown below,
int main(){
// Ambibuity 2
B b;
b.say();
D d;
d.say();
return 0;
}
No comments:
Post a Comment