Theory
એક બટન, બે ભાવ
Canteen ના counter પર એક student પોતાનું card અડાડે છે: till થાળીના 27 રૂપિયા લે છે. એક કર્મચારી એ જ reader પર, એ જ થાળી ખરીદતાં: 24 રૂપિયા.
Cashier એ મશીન બદલ્યું નથી કે જુદો program ખોલ્યો નથી. એક જ ક્રિયા, bill(card), કોણે અડાડ્યું એ પ્રમાણે જુદી વર્તી.
તમારો code પણ આ કરી શકે છે, અને એ વિચારનું ભવ્ય નામ છે: polymorphism, OOP નો ચોથો અને છેલ્લો સ્તંભ.
Theory
એક શબ્દ, અનેક રજૂઆત
તમારાં દાદીમાને, તમારા અધ્યાપકને, અને તમારા સૌથી સારા મિત્રને "નમસ્તે" કહો. એ જ શબ્દ, ત્રણ જુદી રજૂઆત: સૂર, હાવભાવ, હૂંફ બધું ઝીલનાર પ્રમાણે ગોઠવાય છે.
Polymorphism એ code માં બરાબર એ જ છે: એક નામ જેનું વર્તન એને ભજવતા object પ્રમાણે ગોઠવાય છે. બોલાવનાર એક વાત કહે છે; ઝીલનાર નક્કી કરે છે કે એનો એના માટે શું અર્થ છે.
Theory
Polymorphism, ઔપચારિક રીતે
Polymorphism ગ્રીક માંથી આવે છે: poly (અનેક) વત્તા morphe (સ્વરૂપ): એક નામ, અનેક સ્વરૂપ.
પરીક્ષા માટેની વ્યાખ્યા: polymorphism એટલે એક જ function ના નામ, operator કે interface ની જુદા સંદર્ભોમાં જુદી રીતે વર્તવાની ક્ષમતા.
C++ માં "સંદર્ભ" બે ક્ષણે નક્કી થઈ શકે છે:
- compile થતી વખતે (આ દલીલોને કઈ આવૃત્તિ બંધબેસે છે?),
- ચાલતી વખતે (આ call ને ખરેખર કયો object ઝીલી રહ્યો છે?).
At a glance
બે કુટુંબ (વિગત હવે પછીના પાઠોમાં)
| કુટુંબ | ક્યારે નક્કી થાય | કઈ રીતે સિદ્ધ થાય |
|---|---|---|
| Compile-time (static) | Compilation દરમિયાન | Function overloading, operator overloading |
| Run-time (dynamic) | Program ચાલતો હોય ત્યારે | Virtual functions વત્તા inheritance |
Theory
Counter પર બંને કુટુંબ
Compile-time નો સ્વાદ: till પાસે bill(double amount) અને bill(double amount, double discount) છે. બે functions, એક નામ; તમે આપેલી દલીલો જોઈને compiler પસંદ કરે છે. Program ચાલે એ પહેલાં જ પતી ગયું.
Run-time નો સ્વાદ: Student અને Staff બંને Person માંથી વારસો મેળવે છે અને દરેક પોતાનું discount() વ્યાખ્યાયિત કરે છે. Counter પાસે Person નો reference છે; ખરેખરું card અડે ત્યારે જ program ને ખબર પડે છે કે કયું discount() ચલાવવું.
એ જ સ્તંભ, બે પ્રયુક્તિ.
Quiz
Till એ bill(double amt) અને bill(double amt, double disc) વ્યાખ્યાયિત કરે છે. તમે bill(50.0) બોલાવો છો. કઈ આવૃત્તિ ચાલશે એ ક્યારે નક્કી થાય છે, અને એને શું કહેવાય?
- Compile ના સમયે; function overloading (compile-time polymorphism)
- Run ના સમયે; virtual function નું dispatch
- Compile ના સમયે; inheritance
- Run ના સમયે; operator overloading
Show the answer
Compile ના સમયે; function overloading (compile-time polymorphism)
દલીલોની યાદી (એક double) compiler ને પહેલેથી જ બરાબર કહી દે છે કે કઈ આવૃત્તિ મેળ ખાય છે, એટલે નિર્ણય compilation દરમિયાન થાય છે: આ function overloading છે, compile-time નું કુટુંબ. Run-time નું dispatch (વિકલ્પ B) ત્યારે જ આવે છે જ્યારે virtual functions અને base class ના pointers સંડોવાયેલા હોય, અને આ દૃશ્યમાં inheritance તો ક્યાંય છે જ નહીં.
Think first
Run-time નો કિસ્સો ઓળખો
એક function એક જ વાર લખાયું છે: void charge(Person &p) { total = total - p.discount(); }. ક્યારેક Student અપાય છે, ક્યારેક Staff. Tap કરતાં પહેલાં: compiler કેમ નક્કી નથી કરી શકતો કે કયું discount() ચાલશે, અને એને બદલે program એ શું કરવું પડે?
Show the answer
Compile ના સમયે parameter ફક્ત "કોઈક Person" છે: ખરેખરો object (Student? Staff?) ત્યારે જ અસ્તિત્વમાં આવે છે જ્યારે program ચાલે અને ખરેખરું card અડે. એટલે નિર્ણય run time સુધી મુલતવી રાખવો પડે, જ્યાં call એ object ના પોતાના discount() સુધી વળે છે. આ વળાંક થાય એ માટે C++ ને function પર virtual નું નિશાન જોઈએ છે, અને બરાબર ત્યાંથી હવે પછીના પાઠો ઉપાડે છે.
Watch out
વર્ગીકરણનો ફાંદો
પરીક્ષાઓ પૂછે છે: "શું function overloading એ run-time polymorphism છે?" ના: overloading compiler ઉકેલે છે, એટલે એ compile-time (જેને static કે early-bound પણ કહે છે) polymorphism છે.
અને એવો દાવો ન કરો કે polymorphism ને હંમેશા inheritance જોઈએ: run-time ના કુટુંબને જોઈએ છે, પણ overloading તો એક જ class માં, ક્યાંય માતાપિતા વગર ચાલે છે. કુટુંબને પ્રયુક્તિ સાથે મેળવો, કોઈ સાર્વત્રિક નિયમ સાથે નહીં.
Theory
રચનાકારોને એ કેમ ગમે છે
ઉપરનું charge() function હવે ક્યારેય બદલાશે નહીં: આવતા વર્ષે પોતાના discount() સાથે Guest નું card ઉમેરો, અને charge() એને એક પણ ફેરફાર વગર સેવા આપશે. Code વિસ્તાર માટે ખુલ્લો, ફેરફાર માટે બંધ: એ polymorphism નું વ્યાવસાયિક વળતર છે, અને મુલાકાત લેનારા બરાબર એ જ શબ્દોમાં કહે છે.
Summary
Key takeaways
- Polymorphism = એક નામ, અનેક સ્વરૂપ: OOP નો ચોથો સ્તંભ.
- એક call સંદર્ભ પ્રમાણે જુદું વર્તે છે: અપાયેલી દલીલો કે ઝીલનારો object.
- Compile-time કુટુંબ: function અને operator overloading, compiler ઉકેલે છે.
- Run-time કુટુંબ: inheritance સાથે virtual functions, program ચાલતાં ઉકેલાય છે.
- Overloading એ run-time polymorphism નથી: જાણીતો વર્ગીકરણનો ફાંદો.
- નવા derived classes જૂના polymorphic code માં એને સુધાર્યા વગર જોડાઈ જાય છે.
- Memory hook: દાદીમાને, અધ્યાપકને, મિત્રને નમસ્તે.