Experiment 11

Aim: Study of Inheritance, virtual classes and virtual function in C++

Theory:

In C++, inheritance is a process in which one object acquires all the properties and
behaviors of its parent object automatically. In such a way, you can reuse, extend or
modify the attributes and behaviors which are defined in other classes.

In C++, the class which inherits the members of another class is called derived class and
the class whose members are inherited is called base class. The derived class is the
specialized class for the base class.

Advantages of inheritance

Code reusability: Now you can reuse the members of your parent class. So, there is no
need to define the member again. So less code is required in the class.

Types of Inheritance

● Single inheritance
● Multiple inheritance
● Hierarchical inheritance
● Multilevel inheritance
● Hybrid inheritance

Derived class

A Derived class is defined as the class derived from the base class.

Syntax:

class derived_class_name :: visibility-mode base_class_name

// body of the derived class.

}
Where,

derived_class_name: It is the name of the derived class.

visibility mode: The visibility mode specifies whether the features of the base class are
publicly inherited or privately inherited. It can be public or private.

base_class_name: It is the name of the base class.

When the base class is privately inherited by the derived class, public members of the
base class become the private members of the derived class. Therefore, the public
members of the base class are not accessible by the objects of the derived class only
by the member functions of the derived class.

When the base class is publicly inherited by the derived class, public members of the
base class also become the public members of the derived class. Therefore, the public
members of the base class are accessible by the objects of the derived class as well as
by the member functions of the base class.

In C++, the default mode of visibility is private.

The private members of the base class are never inherited.

Single Inheritance

Single inheritance is defined as the inheritance in which a derived class is inherited

from the only one base class.

Where 'A' is the base class, and 'B' is the derived class.

PROGRAM
//241060029
#include <iostream>
using namespace std;

class B
{
int a;//private;cannot be inherited
public:
int b;
void set_ab();
int get_a();
void show_a();
};

class D:public B //public derivation

{
int c;
public:
void mul();
void display();
};

void B :: set_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;
}

int main()
{
D d;
d.set_ab();
d.mul();
d.show_a();
d.display();

d.b=20;
d.mul();
d.display();

return 0;
}

Output
How to make a Private Member Inheritable?

The private member is not inheritable. If we modify the visibility mode by making it public,
this takes away the advantage of data hiding.

C++ introduces a third visibility modifier, i.e., protected. The member which is declared
as protected will be accessible to all the member functions within the class as well as the
class immediately derived from it.

● Public: When the member is declared as public, it is accessible to all the

functions of the program.
● Private: When the member is declared as private, it is accessible within
the class only.
● Protected: When the member is declared as protected, it is accessible
within its own class as well as the class immediately derived from it.
Multilevel Inheritance

When one class inherits another class which is further inherited by another class, it is
known as multi level inheritance in C++. Inheritance is transitive so the last derived
class acquires all the members of all its base classes.

PROGRAM

//241060029
#include <iostream>
using namespace std;

class student
{
protected:
int roll_number;
public:
void get_number(int);
void put_number();
};

void student :: get_number(int a)

{
roll_number=a;
}

void student :: put_number()

{
cout<<"Roll Number = "<<roll_number<<endl;
}

class test : public student

{
protected:
float sub1;
 float sub2;
public:
void get_marks(float, float);
void put_marks();
};

void test :: get_marks(float x, float y)

{
sub1=x;
sub2=y;
}

void test :: put_marks()

{
cout<<"Marks in subject 1 = "<<sub1<<endl;
cout<<"Marks in subject 2 = "<<sub2<<endl;
}
class result: public test //second level derivation
{
float total;
public:
void display();
};

void result :: display()

{
total = sub1+sub2;
put_number();
put_marks();
cout<<"Total= "<<total<<endl;
}

int main()
{
result student1;
student1.get_number(111);
student1.get_marks(75.0, 59.5);
student1.display();
return 0;
}

Output:
Multiple Inheritance

Multiple inheritance is the process of deriving a new class that inherits the attributes
from two or more classes.

Syntax:

class D : visibility B-1, visibility B-2, ?

// Body of the class;

PROGRAM

//241060029
#include <iostream>
using namespace std;

class M
{
protected:
int m;
 public:
void get_m(int);
};

class N
{
protected:
int n;
public:
void get_n(int);
};

class P:public M, public N

{
public:
void display();
};

void M :: get_m(int x)
{
m=x;
}

void N :: get_n(int y)
{
n=y;
}

void P :: display()
{
cout<<"m= "<<m<<endl;
cout<<"n= "<<n<<endl;
cout<<"m*n= "<<m*n<<endl;
}

int main()
{
P p;
p.get_m(10);
p.get_n(20);
p.display();

return 0;
}

Output:
Hybrid Inheritance

PROGRAM

//241060029
#include <iostream>
using namespace std;

class student
{
protected:
int roll_number;
public:
void get_number(int a)
{
roll_number=a;
}
void put_number()
 {
cout<<"Roll number = "<<roll_number<<endl;
}
};

class test:public student

{
protected:
float part1, part2;
public:
void get_marks(float x, float y)
{
part1=x;
part2=y;
}
void put_marks()
{
cout<<endl<<"Marks obtained: "<<endl;
cout<<"Part1 = "<<part1<<endl;
cout<<"Part2 = "<<part2<<endl;
}
};

class sports
{
protected:
float score;
public:
void get_score(float s)
{
score=s;
}
void put_score()
{
cout<<"sports weightage: "<<score<<endl;
}
};

class result: public test, public sports

{
float total;
public:
void display();
};

void result :: display()

{
total= part1+part2+score;
put_number();
put_marks();
put_score();
 cout<<"Total score= "<<total<<endl;
}

int main()
{
result student1;
student1.get_number(123);
student1.get_marks(55.5,67.3);
student1.get_score(6.0);
student1.display();

return 0;
}

Output:

Hierarchical Inheritance

Hierarchical inheritance is defined as the process of deriving more than one class from a
base class.
Syntax:

class A

// body of the class A.

class B : public A

// body of class B.

class C : public A

// body of class C.

class D : public A

// body of class D.
}

PROGRAM

//241060029
#include<iostream>
using namespace std;
class father //Base class declaration
{
int age;
char name [15];
public:
void get()
{
cout<< "Enter Father's name= ";
cin >> name;
cout<< "Enter Father's age= ";
cin >> age;
}
void show ( )
{
cout << "\n Father's name is : "<<name<<endl;
cout << "Father's age is: "<< age<<endl;;
}
};

class son : public father

{
char name [20] ;
int age ;
public:
void get() ;
void show() ;
};
void son :: get ( )
{
father :: get ( ) ;
cout << "Enter son's name= ";
cin >>name;
cout <<"Enter son's age = ";
cin>>age;
}
void son :: show ( )
{
father :: show ( ) ;
cout << "Son's name: " <<name<<endl;
cout << "Son's age is : "<<age<<endl;
}
class daughter : public father
{
char name [15] ;
int age;
public:
void get ( )
{
father :: get ( ) ;
cout << "Enter daughter's name= ";
cin>>name;
cout << "Enter daughter's age= ";
cin >>age;
}
void show ( )
{
father :: show ( ) ;
cout<<endl<< "Daughter's name is: " << name << " and her age is : "<<age<<endl;
}
};
int main ( )
{

son S1;
daughter D1 ;
S1. get ( ) ;
D1. get ( ) ;
S1 .show( ) ;
D1. show ( ) ;
}

Output:
Virtual functions

○ A C++ virtual function is a member function in the base class that you redefine in
a derived class. It is declared using the virtual keyword.
○ It is used to tell the compiler to perform dynamic linkage or late binding on the
function.
○ There is a necessity to use the single pointer to refer to all the objects of the
different classes. So, we create the pointer to the base class that refers to all the
derived objects. But, when the base class pointer contains the address of the
derived class object, it always executes the base class function. This issue can
only be resolved by using the 'virtual' function.
○ A 'virtual' is a keyword preceding the normal declaration of a function.
○ When the function is made virtual, C++ determines which function is to be
invoked at the runtime based on the type of the object pointed by the base class
pointer.

Late binding or dynamic linkage

In late binding function calls are resolved during runtime. Therefore the compiler
determines the type of object at runtime, and then binds the function call.

Rules of Virtual Function

● Virtual functions must be members of some class.

● Virtual functions cannot be static members.
● They are accessed through object pointers.
● They can be a friend of another class.
● A virtual function must be defined in the base class, even though it is not used.
● The prototypes of a virtual function of the base class and all the derived classes
must be identical. If the two functions with the same name but different
prototypes, C++ will consider them as the overloaded functions.
● We cannot have a virtual constructor, but we can have a virtual destructor
● Consider the situation when we don't use the virtual keyword.

Let's see the simple example of C++ virtual function used to invoke the derived class in
a program.

//241060029
#include <iostream>
using namespace std;

class student
{
protected:
int roll_number;
public:
void get_number(int a)
{
roll_number=a;
}
void put_number()
{
cout<<"Roll Number: "<<roll_number<<endl;
}
};

class test: virtual public student

{
protected:
float part1,part2;
public:
void get_marks(float x, float y)
{
part1=x;
 part2=y;
}
void put_marks()
{
cout<<"Marks obtained: "<<endl;
cout<<"part1 = "<<part1<<endl;
cout<<"part2 = "<<part2<<endl;
}
};

class sports:public virtual student

{
protected:
float score;
public:
void get_score(float s)
{
score=s;
}
void put_score()
{
cout<<"Sports weightage: "<<score<<endl;
}
};

class result : public test, public sports

{
float total;
public:
void display();
};

void result :: display()

{
total=part1+part2+score;
put_number();
put_marks();
put_score();

cout<<"Total score= "<<total<<endl;

}

int main()
{
result student1;
student1.get_number(678);
student1.get_marks(73.5,86.0);
student1.get_score(7.0);
student1.display();

return 0;
}

Output:

Pure virtual function

○ A virtual function is not used for performing any task. It only serves as a
placeholder.
○ When the function has no definition, such function is known as "do-nothing"
function.
○ The "do-nothing" function is known as a pure virtual function. A pure virtual
function is a function declared in the base class that has no definition relative to
the base class.
○ A class containing the pure virtual function cannot be used to declare the objects
of its own, such classes are known as abstract base classes.
○ The main objective of the base class is to provide the traits to the derived classes
and to create the base pointer used for achieving the runtime polymorphism.

#include <iostream>

using namespace std;

class Base

public:
 virtual void show() = 0;

};

class Derived : public Base

public:

void show()

std::cout << "Derived class is derived from the base class." << std::endl;

};

int main()

Base *bptr;

//Base b;

Derived d;

bptr = &d;

bptr->show();

return 0;

Output:
Problem statement

Create a base class called shape. Use this class to store two double type values that
could be used to compute the area of figures. Derive two specific classes called triangle
and rectangle from the base shape. Add to the base class, a member function
get_data() to initialize base class data members and another member function
display_area() to compute and display the area of figures.Make display_area() as a
virtual function and redefine this function in the derived classes to suit their
requirements.

#include<iostream>

using namespace std;

class Shape

public: double a,b;

void get_data ()

cin>>a>>b;

virtual void display_area () = 0; //Shape is an abstract class as it’s a pure virtual function

};

class Triangle:public Shape

{

public: void display_area ()

cout<<"Area of triangle "<<0.5*a*b<<endl;

};

class Rectangle:public Shape

public: void display_area ()

cout<<"Area of rectangle "<<a*b<<endl;

};

int main()

Triangle t;

Shape *st = &t;

cout<<"Enter base and altitude: ";

st->get_data();

st->display_area();
Rectangle r;

Shape *sr = &r;

cout<<"Enter length and breadth: ";

sr->get_data();

sr->display_area();

return 0;

Output:

Conclusion:

Thus, the study of Inheritance, virtual functions and virtual classes is complete.