In
protected derivation both public and protected member of the base class become
protected in the derived class.
#include<iostream.h>
#include<conio.h>
class B
{
protected:
int a,b;
public:
void get_ab(
);
};
class D:: public
B
{
public:
int sum( );
};
void B::get_ab(
)
{
a=5,b=10;
}
int D::sum( )
{
return a+b;
}
void main( )
{
clrscr( );
D d;
d.get_ab( );
cout<< “Addition=”
<< d.sum;
getch( );
}
Write a program to show an
example of using ‘protected’ visibility label for public derivation.
#include<iostream.h>
#include<conio.h>
class B
{
protected:
int a,b;
public:
void get_ab(
);
};
class D:: public
B
{
public:
int sum( );
class E:public
D
{
public:
int sub( );
};
void B::get_ab(
)
{
a=5,b=10;
}
int D::sum( )
// function defination
{
return ( a+b);
}
int E:sub( )
// function definition
{
return (a-b);
}
void main( )
{
clrscr( );
E e;//object
e.get_ab( );
// calling the function
cout<< “Addition=”
<< e.sum( );
cout<< “Subtration=”
<< e.sub( );
getch( );
}
Multilevel inheritance
Syntax
class A
{
};
class B:visibility
A
{
};
classC: visibility
B
{
};
Where
visibility may be either private or public or protected.
A class A server as a base class
for the derived class B, which turn serves as a base class for a derived class
C. The class B is known as intermediate base class since it provides a link for
the inheritance between A and C. The chain A,B,C is known as inheritance path.
#include<iostream.h>
#include<conio.h>
class student
{
protected:
int r_no;
public:
void
get_number(int x);
void
put_number ( );
};
void
student::get_number(int x)
{
r_no=x;
}
void
student::put_number()
{
cout<<
“Roll_no=” <<r_no<< “\n”;
}
class
test:public student
{
protected:
float
sub1,sub2;
public:
void
get_marks( float x, float y);
void
put_marks();
};
Void
test::get_marks(float x, float y )
{
sub1=x;
sub2=y;
}
void
test::put_marks( )
{
cout<<
“Marks in sub1=” << “\n”;
cout<<
“Marks in sub2=” << “\n”;
}
class result::public
test
{
float total;
public:
void display(
);
};
void result:display(
)
{
total=sub1+sub2;
put_number( );
put_marks( );
cout<< “total=”
<< total “\n”
}
void main ( )
{
clrscr ( );
ob.reg_number(100);
ob.put_marks(3.5,7.5);
ob.display( );
getch( );
}
Multiple inheritance:
Syntax
class A
{
};
class B
{
};
class C
{
};
class D:visibility
A, visibility B, visibility C
{
};
A class can inherit the
attributes of two or more classes is known as multiple inheritance. Multiple inheritances
allow us to combine the features of several existing classes as a starting
point for defining new classes.
#include<iostream.h>
#include<conio.h>
class B1
{
protected:
int x;
public:
void get_x(int
a);
};
class B2
{
protected:
int y;
public:
void get_y(int
b)
}
class D:
public B1,public B2
{
public:
void display(
);
};
void B1::get_x(int
a )
{
x=a;
}
void B2::get_y(int
b)
{
y=b;
}
void D:;display(
)
{
cout<< “x=” <<x<< “\n”;
cout<< “y=” <<y<< “\n”;
cout<< “x+y=” <<x+y<< “\n”;
}
void main( )
{
clrscr( );
D d;
d.get_x(10);
d.get_y(20);
d.display( );
getch( );
}
Ambiguity resolution in
inheritance
#include<iostream.h>
#include<conio.h>
class B1
{
public:
void display(
);
};
class B2
{
public:
void display(
);
};
class D:public
B1, public B2
{
void display(
);
}
void B1:display(
);
{
cout<< “In
class B1 \n”;
}
void B2:display(
);
{
cout<< “In
class B2 \n”;
}
void D:display(
);
{
cout<< “In
class D \n”;
}
void main( )
{
clrscr( );
D d;
d.display( );
d.B1::display(
);
d.B2::display(
);
getch( );
}
The function in the derived class overwrites the
inherited function and therefore a simple called display ( ) by type of object
will invoked the function defined in D only. However we may invoked the
function defined in B1 and b2 by using the scope resolution operator (: ) to
specify the class.
Hierarchical inheritance:-
Several derived classes which are
inherited by base class.
Syntax:
class A
{
};
class B : visibility A
{
};
class C : visibility A
{
};
class D : visibility A
{
};
#include<iostream.h>
#include<conio.h>
class B
{
protected:
int a,b;
public:
void get_ab(
);
};
class D1:: public
B
{
public:
int sum( );
};
class
D2:public B
{
public:
int mul( );
};
void
B::get_ab( )
{
a=5,b=10;
}
int D1::sum( )
{
return a+b;
}
int D2::mul( )
{
returna*b;
}
void main( )
{
clrscr( );
D1 ob1;
Ob1.get_ab( );
cout<<
“Addition=” << ob1.sum( );
D2 ob2;
Ob2.get_ab( );
cout<<
“Multiplication=” << ob2.mul( );
getch( );
}
Hybrid inheritance:-
Syntax:
class A
{
};
class B : visibility A
{
};
class D
{
};
class C : visibility B,
visibility D
{
};
Where, visibility may be either
private or public.
#include<iostream.h>
#include<conio.h>
class A
{
protected:
int a;
};
class B:: public
A
{
protected:
int b;
};
class D
{
protected:
int c;
};
class c:public
B, public D
{
public:
void get_abc(
)
int sum( );
};
void c:get_abc(
)
{
a=5,b=6,c=7;
}
int c::sum( )
{
return a+b+c;
}
void main
{
clrscr( );
c ob;
ob.get_abc( );
cout<<
“Addition=” << ob1.sum( );
getch( );
}
Virtual Base class
Syntax:
class A
{
};
class B1 : public virtual A
{
};
class B2 : public virtual A
{
};
class C : public virtual B1, public virtual B2
{
//only one copy of class A will
be inherited//
};
Consider a situation when all the
three kinds of inheritance, namely multilevel, multiple and hierarchical
inheritance are involved. The class c has two direct base classes B1 and B2
whose themselves have common base class A. The class C inherits, the data
member and member function of class A via two separate path.
All the public and protected member
of class A are inherited in class C twice first via class B1 and next via class
B2. This means class C would have duplicate set of member inherited form class
A. this introduces ambiguity and should be avoided.
The duplicate of inheritance members
due to these multiple path can be avoided by making the common base class as
virtual base class awhile declaring the direct or intermediate base classes.
When a class is made a virtual
base class, C++ takes necessary care to see that only one copy of that class is inherited,
regardless of how many inheritance path exists between the virtual class and
derives class.
#include<iostream.h>
#include<conio.h>
class A
{
public:
void display(
);
};
class B1: public
virtual A
{
};
class B2:public
virtual A
{
};
class C: public
B1, public B2
{
};
void A::display(
)
{
cout<< “In
the virtual base class A\n=”;
}
void main
{
clrscr( );
c obj;
obj.display(
);
getch( );
}
Abstract class
An abstract class is one that is
not used to create object. It is a design concept in program development and provides
a base upon which other classes may be built.
Since we can’t create object
abstract class, we can create pointers and reference to an abstract class. This
allows abstract classes to support run time polymorphism, which relies upon
base class pointer and references to select he proper virtual function.
Constructor in derived class
If any base class contains
the constructor with one or many argument, then it mandatory for the derived
class to have the construction and pass.
While applying inheritance, we
usually create object using the derived class. Thus it make sense for the derived
class to pas argument to the base class constructor. When the both derived and
base classes contain contractors, the base constructor is executed first and
then the constructor in derived class is executed.
In case of multiple inheritances
the base classes are constructed in the order in which they appear in the
declaration of the derived class.
class A
{
};
class B
{
};
class C: public A, public B
{
};
Similarly in a multilevel
inheritance, the constructor will be executed in the order of inheritance.
Since the derived class takes the
responsibility of supplying initial values to its base class, we supply the
initial values that are required by all the classes together, when a derived
class object is declared.
#include<iostream.h>
#include<conio.h>
class alpha
{
int x;
public:
alpha(int i)
{
x=i;
}
void display_x(
)
{
cout<< “x=”
<< x<< “\n”;
}
};
class beta: public
alpha
{
int y;
public:
beta(int a,
int b):alpha (a)
{
y=b;
};
void display(
)
{
cout<< “y=” << “\n”;
}
};
void main
{
clrscr( );
beta obj(10,20);
ob.display_x(
);
ob.display_y(
);
getch( );
}
The constructor of the derived class
receives the entire list of the values as its arguments and passes them on to
the base constructor in the order in which they are declared in the derived
class. The base constructor are called and executed before executing the
statement in the body of the derived constructor.
The constructor for virtual base
classes are invoked before any non-virtual base classes. If there are multiple
virtual base classes they are invoked in the order in which they are declared.
Any non-virtual base classes are then constructor before the derived class
constructor is executed.
Method of inheritance Order
of execution
class B: public A A(
); base constructor
{ B
( ); derived constructor
}; B(
); base constructor (1st)
class A:public B, public C C(
); base constructor (2nd)
{ A(
); derived
};
Class A:public B, virtual C C( ); virtual base class
B(
); ordinary base
A(
); derived
The general form of defining the derived constructor
Derived _constructor( arglist1, arglist2…..arglist
D):
base1(arglist1), base2(arglist2)
{
body of the derived constructor
};
#include<iostream.h>
#include<conio.h>
class alpha
{
int x;
public:
alpha(int i );
{
x=i;
}
void display_x(
)
{
cout<< “x=”
<< “\n”
{
};
class beta
{
float y;
public:
beta(float j )
{
y=j;
}
void display_y(
)
{
cout<< “y=”
<<y “\n”;
}
};
class gamma:public
alpha, public beta
{
int m;
float n;
public:
gamma( int a,
floab, int c, float d): alpha(a), beta(b)
{
m=c;
n=d;
void display_mn(
)
{
cout<< “m=”<<m<<
“\t” << “n=” <<n “\n”;
}
};
void main( )
{
clrscr( );
gamma ob(5,3,5,10,3.75);
ob.display_x(
);
ob.display_y(
);
ob.display_mn(
);
getch( );
}
Using multilevel inheritance
#include<iostream.h>
#include<conio.h>
class alpha
{
int x;
public:
alpha(int i );
{
x=i;
}
void display_x(
)
{
cout<< “x=”
<< “\n”
}
};
class beta: public
alpha
{
int y;
public:
beta(int a,
int b):alpha(a)
{
y=b;
}
void display_y(
)
{
cout<< “y=”
<<y<< “\n”;
}
};
class gamma:public
beta
{
int z;
public:
gamma( int p, int
q, int r): beta(p,q)
{
z=r;
void display_z(
)
{
cout<< “z=”<<z<<
“\n”;
}
};
void main( )
{
clrscr( );
gamma ob(5,10,15);
ob.display_x(
);
ob.display_y(
);
ob.display_z(
);
getch( );
}
Example of
virtual base class
#include<iostream.h>
#include<conio.h>
class base
{
public:
int i;
};
class d1:virtual
public base
{
public:
int j;
};
class d2: virtual
public base
{
public:
int k;
};
class d3:public
d1,public d2
{
public:
int sum;
};
void main( )
{
clrscr( );
d3 ob;
ob.i=10;
ob.j=20;
ob.k=30;
ob.sum=ob.i+ob.j+ob.k;
cout<< “sum=”
<< ob.sum;
getch( );
}
