Inheritance

Published on January 2018 | Categories: Documents | Downloads: 67 | Comments: 0 | Views: 602
of 16
Download PDF   Embed   Report

Comments

Content

Inheritance 1 Q:-1 what is Inheritance? Explain Types of Inheritance with example. The mechanism of deriving a new class from an old one is called inheritance (or derivation).The old class is referred to as the base class and the new one is called the derived class or subclass. Inheritance is a mechanism of reusing and extending existing classes without modifying them, thus producing hierarchical relationships between them. Inheritance allows us to define a class in terms of another class, which makes it easier to create and maintain an application. This also provides an opportunity to reuse the code functionality and fast implementation time. There are five types of Inheritance are available 1. Single Inheritance 4. Multilevel Inheritance 2. Multiple Inheritance 5. Hybrid Inheritance 3. Hierarchical Inheritance 1. Single Inheritance: - Single Inheritance is method in which a derived class has only one base class. #include <iostream.h> class Value { protected: int val; public: void set_values (int a) { val=a;} In example shows a }; Base class value and a class Cube: public Value Derived class cube { class value contain public: Protected member such int cube() As val { return (val*val*val); } Protected access }; int main () Specifier we can use in { Derived class. Private member can not Cube cub; cub.set_values (5); Be Inheriting. cout << "The Cube of 5 is::" << cub.cube() << endl; return 0; } Result: The Cube of 5 is:: 125

Inheritance 2 2. Multiple Inheritance:- You can derive a class from any number of base classes. Deriving a class from more than one direct base class is called multiple inheritance.  Multiple inheritance enables a derived class to inherit members from more than one parent. Deriving directly from more than one class is usually called multiple inheritance. Syntax:Class C: Public A, Public B { Body of D }

Example class student { protected: int rno,m1,m2; public: void get() { cout<<"Enter the Roll no :"; cin>>rno; cout<<"Enter the two marks :"; cin>>m1>>m2; } }; class sports { protected: int sm; // sm = Sports mark public: void getsm() { cout<<"\nEnter the sports mark :"; cin>>sm; } }; class statement:public student,public sports { int tot,avg;

Inheritance

3

public: void display() { tot=(m1+m2+sm); avg=tot/3; cout<<"\n\n\tRoll No : "<<rno<<"\n\tTotal cout<<"\n\tAverage : "<<avg; } }; void main() { clrscr(); statement obj; obj.get(); obj.getsm(); obj.display(); getch(); }

: "<<tot;

Output: Enter the Roll no: 100 Enter two marks 90 80 Enter the Sports Mark: 90 Roll No: 100 Total : 260 Average: 86.66

Ambiguity: - In multiple inheritance the ambiguity arises when same method name is being used by two derived class and further derivation from these two base classes. To resolve this ambiguity we are using scope resolution operator. class M { public: void display() { cout<<"vimal \n"; } }; class N { public: void display() { cout<<"Vaiwala\n"; } };

Output: Vimal Vaiwala

class P:public M,public N { public: void display(void) { M::display(); N::display(); } }; int main() { clrscr(); P p; p.display(); getch(); }

Inheritance

4

3. Hierarchical Inheritance: - It is the inheritance hierarchy wherein multiple subclasses inherit from one base class  Hierarchical Inheritance is a method of inheritance where one or more derived classes is derived from common base class.  It is the process of deriving two or more classes from single base class. And in turn each of the derived classes can further be inherited in the same way. The base class will include all the features that are common to the subclasses. A subclass can be constructed by inheriting the properties of the base class. A subclass can serve as a base class for the lower level classes and so on. Example:- Hierarchical classification of students in a university Student

Arts Syntax:class A {

Engineering

Medical

. . -------------

}; class B : visibility_label A { ------------}; class C : visibility_label A { ------------}; class D : visibility_label A { ------------}; Here the visibility_label can be private, protected or public. If we do not specify any visibility_label then by default is private.

Mech.

Elec.

class A { public: int val; void getvalue(int j) { val=j; } }; class B : public A { public: void square() { cout<<endl<<val*val; } }; class C : public A { public: void cube() { cout<<endl<<val*val*val; } };

Civil

void main() { int i; clrscr(); B b; C c; cin>>i; b.getvalue(i); b.square(); c.getvalue(i); c.cube(); getch(); }

Output 2 4 8

4. Multilevel Inheritance: - The mechanism of deriving a class from another ‘derived class’ is known as multilevel inheritance.  It is the inheritance hierarchy wherein subclass acts as a base class for other classes.  Multilevel Inheritance is a method where a derived class is derived from another derived class. The class A serve as a base class for the Syntax: Base class derived class B, which in turn serves as a base class A{……..}; class for the derived class C. The class B is class B: public A{…….}; known as intermediate base class since it class C:public B{…….}; Intermediate provides a link for the inheritance between A Base class and C. The chain ABC is known as inheritance path. Derived class Example class C:public B class A { { public: protected: void showC() int x; { public: showA(); void showA() showB(); { cout<<"x*y ="<<x*y; cout<<"enter a value for x:"<<endl; } cin>>x; }; } void main() }; { class B:public A C ob1; { ob1.showc(); protected: } int y; public: Output void showB() Enter value of x = 12 { Enter value of y = 3 cout<<"enter value for y:"; X * Y =36 cin>>y; } }; 5. Hybrid Inheritance The inheritance hierarchy that reflects any legal combination of other four types of inheritance. There could be situations where we need to apply two or more types of inheritance to design a program.  "Hybrid Inheritance" is a method where one or more types of inheritance are combined together and used.

In figure base class A and class B and C are derived from class A. So that path is called Hierarchical Inheritance. Class B and C are the base class for class D. so that path is called multiple inheritance. because there are more then one base class.

Example:class stu { protected: int rno; public: void get_no(int a) { rno=a; } void put_no(void) { out<<"Roll no"<<rno<<"\n";

}

}; class test:public stu { protected: float part1,part2; public: void get_mark(float x,float y) { part1=x; part2=y; } void put_marks() { cout<<"Marks obtained:"<<"part1="<<part1<<"\n"<<"part2="<<part2<<"\n"; } }; class sports { protected: float score; public: void getscore(float s) int main() { { score=s; clrscr(); } result stu; void putscore(void) stu.get_no(123); { stu.get_mark(27.5,33.0); cout<<"sports:"<<score<<"\n"; stu.getscore(6.0); stu.display(); } return 0; }; } class result: public test, public sports { float total; public: void display(void); OUTPUT }; void result::display(void) Roll no 123 { Marks obtained : part1=27.5 total=part1+part2+score; Part2=33 put_no(); Sports=6 put_marks(); Total score = 66.5 putscore(); cout<<"Total Score="<<total<<"\n"; }

Q:-2 How constructor and Destructor calls during Inheritance A derived class inherits the members of its base class. Therefore, when a derived class object is instantiated, its base class members must be initialized in addition to its own members. The base class constructor is called to initialize the base class members of the derived class object. The base class constructor, similar to component objects in a composite class, is called before the derived class object's constructor. Destructors are called in the reverse order. Example class base { public: base() { cout << "Constructing base ... \n"; } ~base() { cout << "Destroying base ... \n"; } }; class derived : public base { public: derived() { cout << "Constructing derived... \n"; Output } Constructing base ... ~derived() Constructing derived... { Destroying derived... cout << "Destroying derived... \n"; Destroying base ... } }; int main() { derived ob; return 0; } Argument values may be passed to the base class and derived class constructors. Member initializer lists must be used to accomplish this. Example class base { int i; public: base(int n) : i(n) {

cout << "Constructing base ...:\n"; cout << "i = " << i << "\n"; } ~base() { cout << "Destroying base ...:\n"; } void showi() { cout << i << "\n"; } }; class derived : public base { int j; public: derived(int n, int m) : base(m), j(n) /* pass arg to base class ** and data member of derived */ { cout << "Constructing derived class...:\n"; cout << "j = " << j << "\n"; } ~derived() { cout << "Destroying derived class...:\n"; } Output:void showj() Constructing base...: { i = 20 cout << j << "\n"; Constructing derived class...: } j = 10 }; 20 int main() 10 { Destroying derived class...: clrscr(); Destroying base ...: derived ob(10, 20); ob.showi(); ob.showj(); The child has two direct base classes ‘parent 1’ and getch(); ‘parent 2’ which themselves have a common base return 0; class ‘grandparent’. The ‘child’ inherits the traits of } ‘grandparent’ via separate paths. It can also inherit directly as shown by the broken line. The Q:-3 Explain Virtual Base class with example ‘grandparent’ is sometimes referred to as indirect base When two or more objects are derived fromclass. a common base class, we can prevent multiple copies of the base class being present inInheritance an object derived from thoseshown objects by the ‘child’ in by fig. might pose declaring the base class as virtual when it is being inherited. Such a base class is known some problem. All the public and protected members of ‘grandparent’ are inherited twice, first via ‘parent 1’ and again ‘parent 2’ This means ‘child’ would have duplicate sets of the members inherited from ‘grandparent’. This introduces ambiguity and should be avoided.

as virtual base class. This can be achieved by preceding the base class’ name with the word virtual. Grandparent

Parent 1

Parent 2

Child

The duplication of inherited members due to these multiple paths can be avoided by making the common base class (ancestor class) as virtual base class. Syntax Class A //grandparent { } Class B1 : virtual public A //parent 1 {

For example: = Assume that class sports derives the roll_number from the class student. Then, the inheritance relationship will be shown in Fig. Student As Virtual base class

As Virtual base class

} Class B2 : public virtual A //parent 2 { } Class C : public B1, public B2 //child { //Only one copy of A //will be inherited } Note: - The Keyword virtual and public may be use in either order. Example class student { protected: int roll_number; public: void get_number(int a) { roll_number =a; } void put_number(void) { out<<"Roll no"<< roll_number <<"\n"; } }; class test: virtual public student { protected: float part1,part2; public: void get_mark(float x,float y) {

Test

Sports

Result Virtual Base Class

part1=x; part2=y; } void put_marks() { cout<<"Marks obtained:"<<"part1="<<part1<<"\n"<<"part2="<<part2<<"\n"; } }; class sports:public virtual student { protected: float score; public: void get_score(float s) int main() { { score=s; clrscr(); } result stu; void put_score(void) stu.get_number(123); { stu.get_mark(27.5,33.0); cout<<"sports:"<<score<<"\n"; stu.get_score(6.0); stu.display(); } return 0; }; } class result: public test, public sports { float total; public: void display(void); OUTPUT }; void result::display(void) Roll no 123 { Marks obtained : part1=27.5 total=part1+part2+score; Part2=33 put_number(); Sports=6 put_marks(); Total score = 66.5 put_score(); cout<<"Total Score="<<total<<"\n"; } Q:-4 Explain This Pointer C++ uses unique keyword called this to represent an object that invokes a member function. this is a pointer that points to the object for which this function was called. This unique pointer is automatically passed to a member function when it is called. The pointer this acts as an implicit argument to all the member functions. class abc The Private variable ‘a’ can be used directly inside a member { function, like a=123; int a; We can also use the following statement to do same job: public: thisa=123; Since C++ permits the use of shorthand form a=123, we have not been using pointer this explicitly so far. However, we have been implicitly using the pointer this when overloading the operators using member function.

void display() { this->a=123; cout<<a; } }; main() { clrscr(); abc a; a.display(); getch(); }

Output:= 123

Q:-5 Explain pointer to derived classes. We can use pointers not only to the base objects but also to the objects of derived classes. Pointers to objects of a base class are type-compatible with pointers to objects of a derived class. Therefore, single pointer variable can be made to point object belonging to different classes. Explanation of Example Example In function main, we create two pointers that point to class CPolygon objects of class CPolygon (ppoly1 and ppoly2). Then we { assign references to rect and trgl to these pointers, and protected: because both are objects of classes derived from CPolygon, int width, height; both are valid assignment operations. public: void set_values (int a, int b) { width=a; height=b; } }; class CRectangle: public CPolygon { public: int area () { return (width * height); } }; class CTriangle: public CPolygon { public: int area ()

Output 20 10

{ return (width * height / 2); } }; int main () { clrscr(); CRectangle rect; CTriangle trgl; CPolygon * ppoly1 = &rect; CPolygon * ppoly2 = &trgl; ppoly1->set_values (4,5); ppoly2->set_values (4,5); cout << rect.area() << endl; cout << trgl.area() << endl; return 0; } Q:-6 Explain Virtual Function With example  In object-oriented programming, a virtual function or virtual method is a function or method whose behavior can be overridden within an inheriting class by a function with the same signature. When we use the same function name in both base and derived classes, the function in base class is declared as virtual using keyword virtual preceding its normal declaration. When a function is made virtual, C++ determines which function to use at run time based by making the based on the type of object pointer to by base pointer, rather than the type pointer. Thus, by making the base pointer to point to different objects, we can execute different versions of the virtual function. class Base int main () { { public: clrscr(); void display() Base B; { Derived D; cout<<"\n Display base"; Base *bptr; } cout<<"\n bptr points to base \n"; virtual void show() bptr=&B; { bptr -> display();//call base version cout<<"\n show base"; bptr -> show();//call base version } cout<<"\n\n bptr points to derived \n"; }; bptr=&D; class Derived: public Base bptr -> display();//calls base version Output { bptr show();//calls bptr -> points to base Derived version public: return 0; void display() } Display base { Show base cout<<"\n Display Derived"; } bptr points to Derived Display base Show derived

void show() { cout<<"\n show derived"; } }; Rules for virtual function 1. The virtual function must be member of base class 2. They cannot be static members 3. They are accessed by using object pointers 4. Prototype of base class function & derived class must be same 5. Virtual function in base class must be defined even though it is not used 6. A virtual function can be friend function of another class 7. We could not have virtual constructor 8. If a virtual function is derived in base class, it need not be necessarily redefined in the derived class 9. Pointer object of base class can point to any object of derived class but reverse is not true 10. When a base pointer points to derived class, incrementing & decrementing it will not make it point to the next object of derived class Q:-7 Explain pure virtual function A pure virtual function is a function declared in a base class that has no definition relative to the base class. In such cases, the compiler requires each derived class to either define the function or redeclare it as a pure virtual function To create a pure virtual function, rather than define a body for the function, we simply assign the function the value 0. If you have a pure virtual, the class becomes abstract. You cannot create an object of it.

class base { public: //pure virtual function virtual void show()=0; }; class derived1 : public base { public: void show() { cout<<"\n Derived 1"; } Q:-8 Explain Abstract };

void main() { base *b; derived1 d1; b = &d1; b->show(); } Output Derived 1

Class An abstract class is one that is not used to create objects. An abstract class is designed only to act as a base class. It is a design concept in program development and provides a base upon which other classes may be built. Allows the base class to provide only an interface for its derived classes. Prevents anyone from creating an instance of this class. A class is made abstract if at least one pure virtual function defined.

Note: - Take above example

Sponsor Documents

Or use your account on DocShare.tips

Hide

Forgot your password?

Or register your new account on DocShare.tips

Hide

Lost your password? Please enter your email address. You will receive a link to create a new password.

Back to log-in

Close