Inheritance in C++ in Hindi - इन्हेरिटेंस और उसके प्रकार

Inheritance क्या है? उनके प्रकार और Access mode की संपूर्ण जानकारी

What is Inheritance in C++ in Hindi

Inheritance C++, Classes की महत्त्वपूर्ण विशेषता है।

Inheritance एक ऐसी प्रक्रिया है जिसके द्वारा पहले से मौजूद Classes से नई Classes बनाई जाती है।

पहले से मौजुद Classes को Base/Super/Parent Classes कहते है तथा नई Classes को Derived/Sub/Child Classes कहते हैं।

Derived Class, Base Class की properties और methods को प्राप्त करता है , उसमे नया जोड़ सकता है और जो उसे Base class से प्राप्त हुआ है

उसे Modify भी कर सकता है।

Inheritance आपको एक ही Code को Reuse करने की अनुमति देता है जिससे आपका समय और परिश्रम बचता है।

मान लीजिए आपके पास Car नाम से एक Base class है जिसके कुछ सामान्य विशेषताएं जैसे Start, Stop, Accelerate है इस Class के लिए आप Derived class जैसे Maruti Suzuki Alto, Tata Nexon, Creta, Scorpio, Tiago आदि Define कर सकते है।

इसमें प्रत्येक Car के पास Base class के Properties के साथ स्वयं कि भी अलग अलग Properties जैसे Model, Colour, Price आदि होंगे।

Syntax for Inheritance in C++

class DerivedClassName: access- specifier BaseClassName{

//Derived class members

data_members;

member_functions;

};

ऊपर के Syntax में

class:

एक नया class बनाने के लिए यह एक keyword है

DerivedClassName:

यह नए Class का नाम है जो Base class को Inherit करेगा

access- specifier:

यह बताता है की Base class की Properties, Derived class में किस प्रकार से (Private, Protected,Public) Derive की गई है।

BaseClassName:

यह Base class का नाम है जिससे Inherit किया जाता है।

Types of Inheritance in C++ in Hindi

C++ में Inheritance के निम्न प्रकार होते हैं।

1) Single Inheritance

2) Multiple Inheritance

3) Multilevel Inheritance

4) Hierarchical Inheritance

5) Hybrid Inheritance

Single Inheritance

जब एक Derived class केवल एक Base class की Properties और Methods को Inherit करती है उसे Single Inheritance कहते है।

दूसरे शब्दों में Single Inheritance वह है जिसमें एक Class में केवल एक ही Direct base class हो सकता हैं।

Syntax:

class A {

// Members of class A (Base class)

class B : public A{

// Members of the B(derived class)

};

Program for Single Inheritance

#include<iostream>
using namespace std;
class Base{
public:
void Display(){
cout<<"I am from base class";
      }
};
class Derived: public Base{
};
int main(){
Derived obj;
obj. Display(); //Accessing base class function
return 0;
};

Output:

I am from base class

Explanation:

1) ऊपर Program मे एक Base class define किया गया है जिसके पास Display() नाम से एक Member function हैं।

2) अब दूसरा एक नया Derived class बनाया गया है जिसे Base class से Inherit किया गया है।

3) main function के अंदर Derived class का Object 'obj' बनाया जाता है जिसके द्वारा Base class के member function Display() को call किया जाता है क्योंकि Derived class, Base class के Properties और Methods को Inherit कर सकता है।

Multiple Inheritance

C++ में Multiple inheritance एक ऐसा feature है जो एक Derived class को एक से ज्यादा Base class की Properties और Methods को Inherit करने की अनुमति देता है।

दूसरे शब्दों में कहें तो Multiple Inheritance में एक Class के कई Ditect base classes हो सकते हैं।

Syntax:

class A {

// Members of A(First base class)

};

class B {

// Members of B(Second base class class

};

class C : public A, public B{

// Members of C (Derived class)

};

Program for Multiple Inheritance

#include<iostream> using namespace std; // Base class 1 class Vehicle { public: void start() { cout << "Starting..." << endl; } }; // Base class 2 class Twowheeler { public: void accelerate(){ cout << "accelerating to increase the speed" << endl; } };
class Bike: public Vehicle, public Twowheeler { // Derived class, inherits from Vehicle and Twowheeler public: void Startengine() { cout << "Engine is Starting..." << endl; } }; int main(){ Bike obj; obj.start(); obj.accelerate(); return 0; };

Output:

Starting...

accelerating to increase the speed

Explanation:

1) Vehicle और Twowheeler दो Base classes हैं जिसमे क्रमश: start() और accelerate() दो Member functions define किया गया है।

2) Bike एक Derived class, है जिसे दोनों Base classes अर्थात Vehicle और Twowheeler से Inherit किया जाता है

चूंकि Bike दोनो Base classes से Inherit हुआ है अतः वह दोनों के Member functions start() और accelerate() को Access कर सकता है Bike के पास स्वयं के भी अपने Member function Startengine() नाम से है।

3) main function के अंदर Bike class के लिए Object(obj) का निर्माण करते है ताकि obj के द्वारा Base classes के Member functions को Access किया जा सके जैसे कि ऊपर Program में दिखाया गया है।

Multi-level Inheritance

Multilevel inheritance तब होता है जब एक Class अन्य Class से Derived होता है, जो स्वयं दूसरे Class से Derived होता है।

यह एक श्रृंखला बनाता है जहां प्रत्येक Class अपने से ऊपर वाले Class से properties और methods Inherit करता है।

Syntax:

class A{

// Members of A (Base class)

};

class B : public A{

// Members of B(Derived class)

};

class C : public B {

// Members of C(Derived class)

};

Program for Multi-level Inheritance

#include<iostream> using namespace std; // Base class class Person{ public: void work() { cout << "A person need to work ." << endl; } }; // Derived class class Employee : public Person { public: void earnMoney() { cout << "Employee work to earn money." << endl; } }; // Further derived class class Teacher : public Employee{ public: void teach() { cout << "A teacher teach the students." << endl; } }; int main() { Teacher t; t.work (); // Inherited from Person #include using namespace std; // Base class class Person{ public: void work() { cout << "A person need to work ." << endl; } }; // Derived class class Employee : public Person { public: void earnMoney() { cout << "Employee work to earn money." << endl; } }; // Further derived class class Teacher : public Employee{ public: void teach() { cout << "A teacher teach the students." << endl; } }; int main() { Teacher t; t.work (); //Inherited from Person t.earnMoney(); // Inherited from Employee t.teach(); //Defined in Teacher class itself return 0; } t.earnMoney(); // Inherited from Employee t.teach(); // Defined in Teacher class itself return 0; }

Output:

A person need to work .

Employee work to earn money.

A teacher teach the students.

Explanation:

ऊपर के Program में

1) Person एक Base class है

2) Employee class, Person class से Derived हुआ है।

3) Teacher class, Employee class से Derived हुआ है।

4) main function के अंदर Teacher class का object 't' नाम से बनाया जाता है इसका उपयोग Person और Employee class की Properties और Methods Inherit करने के लिए किया जाता है।

इस object (t) का प्रयोग कर हम दोनो Classes के Member functions को Access करने मे किया जाता है।

Hierarchical Inheritance

C++ में Hierarchical inheritance उस समय होता है जब कई Classes एक Base class से Derived होते हैं या कई Derived classes द्वारा एक Base class को Share किया जाता है।

इस प्रकार की Inheritance में प्रत्येक Derived class, एक ही Base class की Properties तथा Methods को Inherit करता है।

इस प्रकार की Inheritance उस समय उपयोगी होती है जब Base class, Common functionality को आप Derived class में विभिन्न तरीकों से विस्तारित करना चाहते है।

Syntax:

class A {

// Members of A(Base class)

};

class B: public A{

// Members of B(First derived class)

};

class C: public A{

// Members of C(Second derived class)

};

class D: public A{

// Members of D(Third derived class)

};

Program for Hierarchical Inheritance

#include<iostream> using namespace std;
// Base class class InputDevices{ public: void input(){ cout << "Input devices allow data entry and control." << endl; } }; // Derived class 1 class Keyboard : public InputDevices{ public: void typing() { cout << "A keyboard types data into a computer." << endl; } }; // Derived class 2 class Mouse : public InputDevices { public: void pointing() { cout << "A mouse points and controls the computer cursor." << endl; } }; int main() { Keyboard obj1; Mouse obj2; obj1.input (); obj1.typing(); obj2.input(); obj2.pointing(); return 0; }

Output:

Input devices allow data entry and control.

A keyboard types data into a computer.

Input devices allow data entry and control.

A mouse points and controls the computer cursor.

Explanation:

1) Base Class (`InputDevices`):

इस Class में एक Method `inputDevices()` Define किया गया है जो Input Devices के Use के बारे मे एक General message प्रदर्शित करता है।

2) Derived Classes:

`Keyboard` और `Mouse` दोनो को `InputDevices` Base class से Inherit किया जाता है।

`Keyword` में एक method `typing ()` , Define किया गया है जो Keyboard के Use को बताता है।

`Mouse` में भी एक method `pointing()`, Define किया गया है जो Mouse के Use को बताता है।

3) Main Function:

main function के अंदर `Keyboard` और `Mouse`, Derived class के लिए दो objects क्रमश: obj1 और obj2 का निर्माण किया जाता है ।

इन Object के द्वारा Base class के function तथा अपने अपने Class के member function को Call किया जाता है जैसे कि ऊपर Program में दिया गया है।

Hybrid Inheritance

C++ मे Hybrid inheritance में विभिन्न प्रकारो के Inheritance को एक Program में मिलाया जाता है

अर्थात दो या दो से अधिक प्रकारों की Inheritances को एक ही समय में Execute किया जाता है।

इसमें आम तौर पर Single, Multiple और Multilevel inheritance का मिश्रण शामिल होता है।

Syntax:

class A{

// Members of A( Base class)

};

class B : public A{

// Members of B(First derived class)

};

class D: public A {

// Members of D (Second derived class)

};

class C: public B, public D {

// Members of C(Hybrid derived class)

};

Program for Hybrid Inheritance

#include<iostream>
using namespace std;
class Base {
public:
void display(){
cout<<"I am base class"<<endl;
     }
};
class Derived1: public Base {
public:
void show(){
cout<<"I am Derived1 class"<<endl;
     }
};
class Derived2:public Base{
public:
void print(){
cout<<"I am Derived2 class"<<endl;
    }
};
class Final: public Derived1, public Derived2{
public:
void allDisplay(){
cout<<"I am final class"<<endl;
    }
};
int main(){
Derived1 d1;
Derived2 d2;
Final f;
d1.display();
d2.display();
f.show ();
f.print();
f.allDisplay();   
return 0;
};

Output:

I am base class

I am Derived1 class

I am Derived2 class

I am final class

Explanation:

1) Base Class (Base):

यह Base class है जिसमें एक Method display() Define किया गया है।

2) Derived Classes (Derived1 और Derived2):

दोनों Derived classes Base से Inherit होते हैं दोनो Derived class के अपने Methods है Derived1 में show() तथा Derived2 में print() है।

3) Final Class (Final):

यह Derived1 और Derived2 से Inherit होता है और इसमें एक method allDisplay() नाम से Define किए जाते हैं।

4) Main Function:

Derived1, Derived2, और Final के Object बनाए जाते हैं

display() को दोनो Derived1 और Derived2 के Objects से Call किए जाते हैं, जो Inherited functionality को प्रदर्शित करता है।

show() और print() methods को Final के object द्वारा Call किए जाते हैं।

Constructor and Destructor Inheritance in C++ in Hindi

C++ में Constructors और Destructor inheritance में एक महत्त्वपूर्ण भूमिका निभाते है।

जब एक Derived class का एक Object का निर्माण किया जाता है तब Base और Derived दोनो Classes के Constructors Call किए जाते हैं।

वैसे ही जब एक Object नष्ट होता है किया जाता है तब Base और Derived दोनो Classes के

Destructors, Call किए जाते हैं।

Program for Costructor and Destructor Inheritance

#include<iostream>
using namespace std;
class A{
public:
       A(){
      cout<<"I am a Constructor from Base class."<<endl;
    }
    ~A(){
      cout<<"I am a Destructor from Base class."<<endl;
     }
};
class B: public A{
public:
       B(){
cout<<"I am a Constructor from Derived class."<<endl;
  }
      ~B(){
cout<<"I am a Destructor from Derived class."<<endl;
   }
};
int main(){
B obj;
return 0;
};

Output:

I am a Constructor from Base class.

I am a Constructor from Derived class.

I am a Destructor from Derived class.

I am a Destructor from Base class.

Explanation:

1) A(Base Class):

इसमें A() Constructor और ~A() Destructor member functions define किया गया है जो कुछ Message print करता है।

2) B(Derived Class):

B class को A class से Inherit किया जाता है इसमें भी

इसमें B() Constructor और ~B() Destructor member functions define किया गया है जो कुछ Message print करता है।

3) Main function:

जब B obj; का निर्माण किया जाता है तब निम्न Execution होता है

1) Base constructor पहले Call किया जाता है

अर्थात

"I am a Constructor from Base class."

2) Derived constructor को उसके बाद Call किया जाता है।

अर्थात

"I am a Constructor from Derived class."

3) Destruction:

जब object scope से बाहर जाता है तब निम्न प्रकार से Destructor को Call किया जाता है।

Derived destructor को पहले Call किया जाता है।

अर्थात

"I am a Destructor from Derived class."

उसके बाद Base destructor को call किया जाता है।

अर्थात

"I am a Destructor from Base class."

Modes of Inheritance in C++ in Hindi

Inheritance का Mode या निर्धारित करता है कि Base class के Members, को हम Derived class में कैसे Access कर सकते हैं।

C++ में हम Data members और Functions के Access level का उल्लेख कर सकते हैं अतः Access control के निम्न levels होते हैं

1) Public

2) Protected

3) Private

Public Inheritance Mode

Syntax:

class Derived : public Base {

................

};

Base class के Public members Derived class में भी Public रहते हैं।

Base class के Protected members Derived class में भी Protected रहते हैं।

Base class के Private members को Derived class में सीधे Access नही किए जा सकते।

Protected Inheritance Mode

Syntax:

class Derived : protected Base {

................

};

Base class के Public members Derived class में Protected बन जाते हैं।

Base class के Protected members Derived class में भी Protected रहते हैं।

Base class के Private members को Derived class में सीधे Access नही किए जा सकते।

Private Inheritance Mode

Syntax:

class Derived : private Base {

................

}

Base class के Public members Derived class में Private बन जाते हैं।

Base class के Protected members Derived class में भी Private बन जाते हैं।

Base class के Private members को Derived class में सीधे Access नही किए जा सकते।

Program for Access mode of Inheritance

#include <iostream>
using namespace std;

class Base 
{
private:
    int x;
protected:
    int y;
public:
    int z;
    void funBase ()
    {
        x = 5;
        y = 15;
        z = 10;
    }
};
class Derived1:public Base
{
    // x is private(can't is be accessed from B)
    // y is protected
    // z is Public

public:
    void funDerived1()
    {
        //x = 20; //Error 
         y = 15;
        z=30; 
    }
    void showDerived1()
    {
//x is Private member of Base class can't be accessed 
     //cout << "Derived1 class can't access x: " << x << endl;
    cout << "Derived1 class can access y: " << y << endl;
   cout << "Derived1 class can access z: " << z<<endl;
    }
};
class Derived2:protected Base 
{
    // x can't be accessed 
    // y is protected
    // z is protected 
public:
    void funDerived2()
    {
        //x = 40;//Error 
        y = 30;
        z=55;
    }
    void showDerived2()
    {
         //cout << "Derived2 class can't access x: " << x << endl;
    cout << "Derived2 class can access y: " << y << endl;
   cout << "Derived2 class can access z: " << z<<endl;
    }
};
class Derived3:private  Base // 'private' is default for classes
{
    // x can't be accessed 
    // y is private
    // z private 
public:
    void funDerived3()
    {
     //Error x = 23;//Error 
        y = 75;
        z=56; 
    }
    void showDerived3()
    {
        //cout << "Derived3 class can't access x: " << x << endl;
    cout << "Derived3 class can access y: " << y << endl;
   cout << "Derived3 class can access z: " << z<<endl;
    }
};
int main()
{
    Derived1 d1;
    // In Derived1 class only Public members 'z' can be accessed from outside the class
    d1.z = 21;
    //protected (y) and private(x) data members can't be accessed from outside the class
    //d1.x = 26;
    //d1.y = 24;
    d1.funDerived1();
    d1.showDerived1();

    Derived2 d2;
//in Derived2 class the protected(y,z) and private(x)  data members can't be accessed from outside the class
    //d2.z= 21;
    //d2.x = 26;
    //d2.y = 24;
    d2.funDerived2();
    d2.showDerived2();

    Derived3 d3;
    //In Derived3 class private data members(x,y,z) can't be accessed from outside the class 
    //d3.z = 21;
    //d3.x = 26;
    //d3.y = 24;
    d3.funDerived3();
    d3.showDerived3();
}

Output:

Derived1 class can access y: 15

Derived1 class can access z: 30

Derived2 class can access y: 30

Derived2 class can access z: 55

Derived3 class can access y: 75

Derived3 class can access z: 56

Explanation:

1) Class Base
Class Base में निम्न Data Members और Member function होते हैं।
a) Data members
Private member: `x`
Protected member: `y`
Public member: `z`

b) Member functions
- Public method: `funA()`
`x`, `y`, और `z` को Value assign कर Initialize किया जाता है।

2) Class Derived1: public Base
Base class से Public Inherit होने के बाद Base class के Members Derived1 class में निम्न Access mode में आ जाते हैं ।
a) Data members
`x` को Access नही कर सकते (Private होने के कारण)
`y` protected बन जाता है
`z` public बन जाता है

b) Member functions
`funDerived1()`, `
y` और`z` की value set की जाती है
- `DispalyDerived1()`
`y` और `z` की value को Display किया जाता है।

3) Class Derived2: protected Base
a) Data members
`y` और `z` protected बन गए
`x` को Access नही कर सकते

b) Member functions
`funDerived2()`
`y` और`z` की value set की जाती है
`DispalyDerived2()`
`y` और `z` की value को Display किया जाता है।

4) Class Derived3: private Base
a) Data members
`y` और `z` private बन जाते है
`x` को Access नही कर सकते

b) Member functions
-`funDerived3()`
y` और`z` की value set की जाती है
`DispalyDerived3()`
`y` और `z` की value को Display

5) Main Function
Classes Derived1, Derived2, Derived3 की Objects बनाई जाती है
ताकि Members को Access किया जा सकें लेकिन Class के बाहर Derived2 class के public member 'z' को ही Access किया जा सकता है क्योंकि 'x' private और 'y' protected member होने के कारण उसे Access नही किया जा सकता है।

`funDerived1()`, `funDerived2()`, और`funDerived3()`Methods को Message display करने के लिए, Call किया जाता है।