Theory
એક જ class બે વાર લખવો
Canteen સભ્યપદનાં cards શરૂ કરે છે. તમે Student class લખો છો: નામ, ID, show(), વત્તા 10% student નું discount. પછી કર્મચારીઓને cards જોઈએ છે, એટલે તમે file ની નકલ કરો છો, નામ બદલીને Staff કરો છો, discount બદલીને 20% કરો છો.
પછીના અઠવાડિયે college ફોન નંબર ઉમેરવાનું કહે છે. હવે તમે બે files માં ફેરફાર કરો છો, અને એક ભૂલી જાઓ છો. બે મહિના પછી પાંચ પ્રકારનાં cards છે અને દરેક ફેરફાર એટલે પાંચ સુધારા.
નકલ કરીને ચોંટાડવું એ ફરી વાપરવું નથી. C++ પાસે ખરેખરું ફરી વાપરવું છે: inheritance.
Theory
કુટુંબની મિલકત
સંતાન કુટુંબનું ઘર ફરી બાંધતું નથી; એ ઘર વારસામાં મેળવે છે અને એક માળ ઉમેરે છે.
C++ માં, derived class એ base class ની માલિકીનું બધું (એના members) વારસામાં મેળવે છે અને પછી એને ખાસ બનાવે એ ઉમેરે છે કે ગોઠવે છે. Student અને Staff બંને Person માંથી નામ, ID અને show() વારસામાં મેળવે છે; દરેક ફક્ત પોતાનો discount નો નિયમ ઉમેરે છે. એક ઘર, અનેક માળ, ઈંટોની નકલ નહીં.
Theory
Inheritance, ઔપચારિક રીતે
Inheritance એ એવી પ્રયુક્તિ છે જેના દ્વારા એક class (derived કે સંતાન class) બીજા class (base કે માતાપિતા class) ના ગુણધર્મો અને વર્તન મેળવે છે.
સ્વરૂપ:
class Student : public Person { ... };
વિસર્ગને "એક પ્રકારનું છે" તરીકે વાંચો. ત્યાંનું public એ inheritance નો પ્રકાર છે: public inheritance સાથે, base ના public members સંતાનમાં public જ રહે છે.
બે ફાયદા: ફરી વાપરવાની ક્ષમતા (એક વાર લખો, દરેક સંતાનમાં વાપરો) અને ક્રમવ્યવસ્થા (code વાસ્તવિક જગતના "એ પ્રકારનું છે" સંબંધોનું પ્રતિબિંબ પાડે છે).
Practical
Person એક વાર, cards કાયમ
#include <iostream>
#include <cstring>
using namespace std;
class Person { // base class
protected:
char name[30];
public:
void setName(const char n[]) { strcpy(name, n); }
void show() { cout << "Card holder: " << name << endl; }
};
class Student : public Person { // derived: single inheritance
public:
double discount() { return 0.10; }
};
class Staff : public Person { // Person now has two children
public:
double discount() { return 0.20; }
};
int main() {
Student s;
s.setName("Riya"); // inherited from Person
s.show(); // inherited from Person
cout << s.discount();// Student's own addition
return 0;
}
At a glance
Inheritance ના પાંચ પ્રકાર
| પ્રકાર | આકાર | ઉદાહરણ |
|---|---|---|
| Single | A → B | Person → Student |
| Multilevel | A → B → C (સાંકળ) | Person → Student → CommitteeStudent |
| Multiple | A + B → C (બે માતાપિતા) | Student + SportsMember → Captain |
| Hierarchical | A → B, A → C (એક માતાપિતા, અનેક સંતાનો) | Person → Student, Staff, Guest |
| Hybrid | ઉપરનાંનું મિશ્રણ | Hierarchical વત્તા multiple ભેગાં |
Think first
એ આકારનું નામ આપો
Canteen ના classes વધે છે: Person → Student, Person → Staff, અને Student → CommitteeStudent. Tap કરતાં પહેલાં: આ આકૃતિમાં inheritance ના કયા બે પ્રકાર છે?
Show the answer
Hierarchical (Person ને બે સંતાનો છે, Student અને Staff) અને multilevel (Person → Student → CommitteeStudent ની સાંકળ). એક જ રચનામાં બે શુદ્ધ પ્રકાર ભેગા થયા હોવાથી, આખું ચિત્ર hybrid ગણાય છે. પરીક્ષાઓ ઘણી વાર બરાબર આવી આકૃતિ દોરીને હાજર દરેક પ્રકારનું નામ પૂછે છે, એટલે સાંકળો અને ફેલાવો બંને શોધો.
Quiz
class Person માં private: char name[30] છે. class Student : public Person એના પોતાના member function ની અંદર name ને સીધું વાપરવાનો પ્રયત્ન કરે છે. શું થાય?
- Compile ની ભૂલ: private members વારસામાં મળે છે પણ derived class માં પ્રાપ્ય નથી
- એ ચાલે છે: સંતાનો માતાપિતાનું બધું વાપરી શકે
- Runtime ની ભૂલ: name અસ્તિત્વમાં છે પણ એમાં કચરો છે
- એ ત્યારે જ ચાલે જ્યારે Student એ Person ની જ file માં હોય
Show the answer
Compile ની ભૂલ: private members વારસામાં મળે છે પણ derived class માં પ્રાપ્ય નથી
Private એટલે સંતાનો માટે પણ private: member એ Student ના object ની અંદર અસ્તિત્વમાં છે પણ compiler એ Student ના code માંથી સીધી પહોંચની ના પાડે છે. પ્રમાણભૂત ઉકેલ બરાબર એ જ કારણ છે જેના માટે protected છે (class અને એના derived classes ને પ્રાપ્ય, છતાં બહારથી છુપાયેલું). વિકલ્પ B એ ગેરસમજ છે જેનો આ પ્રશ્ન શિકાર કરે છે; file ની જગ્યા (વિકલ્પ D) પહોંચના નિયંત્રણમાં કોઈ ભાગ ભજવતી નથી.
Watch out
Marks લાયક બે ફાંદા
Private વાપરવા માટે આગળ જતું નથી: "private members વારસામાં મળે છે પણ derived class માં પ્રાપ્ય નથી; protected આનો ઉકેલ છે" લખો અને પરીક્ષાઓ જે મુદ્દો શોધે છે એ તમે મેળવી લો.
Multiple અને multilevel ની ગૂંચવણ: multiple = એકસાથે બે માતાપિતા (C++ માં ચાલે છે, Java માં જાણીતી રીતે નહીં); multilevel = દાદાની સાંકળ. Hybrid inheritance diamond problem સર્જી શકે છે (એક દાદા સુધી બે રસ્તે પહોંચાય); એ જોખમનું નામ આપવું એ વધારાના marks નું ક્ષેત્ર છે.
Theory
હવે પછીના પાઠોને આ કેમ જોઈએ
Inheritance એ મંચ છે જેના પર બાકીનું Unit 2 અને આખું Unit 3 ભજવાય છે: સંતાન જન્મે ત્યારે constructors પહેલાં base નાં ચાલે છે, અને polymorphism (એક જ discount() નું call Student અને Staff માટે જુદું વર્તવું) ફક્ત એટલા માટે અસ્તિત્વમાં છે કારણ કે બંને સંતાનો Person નો base વહેંચે છે. Cards નું કુટુંબ યાદ રાખો; એ બાકીના દરેક OOP પાઠમાં પાછું આવે છે.
Summary
Key takeaways
- Inheritance: derived class એ base class ના members મેળવે છે અને એમને લંબાવે છે.
- સ્વરૂપ: class Child : public Parent { }; public inheritance public members ને public રાખે છે.
- પાંચ પ્રકાર: single, multilevel (સાંકળ), multiple (બે માતાપિતા), hierarchical (ફેલાવો), hybrid (મિશ્રણ).
- Private members વારસામાં મળે છે પણ સંતાનને અપ્રાપ્ય રહે છે; protected એનો ઉકેલ છે.
- C++ માં multiple inheritance કાયદેસર છે (Java માં નહીં); hybrid diamond problem સર્જી શકે છે.
- ફાયદા: ફરી વાપરવાની ક્ષમતા અને વાસ્તવિક જગતની 'એ પ્રકારનું છે' ક્રમવ્યવસ્થા.
- Memory hook: ઘર વારસામાં લો, એક માળ ઉમેરો.