Theory
તમને ગૂંચવવા માટે બનેલા બે શબ્દ
Overloading. Overriding. બે શબ્દો જે નવ અક્ષર વહેંચે છે, એક જ એકમમાં વસે છે, અને લગભગ દર વર્ષે એક જ પરીક્ષાના પ્રશ્નમાં સાથે દેખાય છે: "function overloading અને function overriding ને અલગ પાડો."
મૌખિક પરીક્ષામાં એમને ભેળવી નાખો, અને પછીના પ્રશ્નો ઝડપથી અસુવિધાજનક બની જાય છે.
સારા સમાચાર આ છે: તમે નામ પાડ્યા વગર બંને વાપરી ચૂક્યા છો. Till ની બે bill() આવૃત્તિઓ? Overloading. Student એ Person નું discount() ફરી લખ્યું એ? Overriding.
Theory
એ જ counter સામે કુટુંબની રીત
Overloading એટલે એક counter જે chai, chai(large), chai(large, extra sugar) આપે છે: એક નામ, અને તમે શું માંગ્યું એ જોઈને cashier રીત પસંદ કરે છે.
Overriding એટલે કુટુંબની franchise શાખા માતાપિતાની પ્રમાણભૂત થાળીની રીત લઈને પોતાની આવૃત્તિથી બદલી નાખે છે, વાનગીનું નામ એ જ, order ની ચિઠ્ઠી એ જ, રસોડું જુદું. તમને કઈ મળે એ કઈ શાખા તમને પીરસે છે એના પર આધારિત છે.
Theory
બંને, ઔપચારિક રીતે
Function overloading: એક જ scope માંનાં બે કે વધુ functions નામ વહેંચે છે પણ એમની parameter ની યાદી (parameters ની સંખ્યા કે પ્રકાર) જુદી હોય છે. Compiler દલીલો મેળવીને પસંદ કરે છે.
double bill(double amt);
double bill(double amt, double disc);
Function overriding: derived class એ base class ના function ને એ જ નામ અને એ જ signature વાપરીને ફરી વ્યાખ્યાયિત કરે છે. એ સંતાન માટે સંતાનની આવૃત્તિ માતાપિતાની જગ્યા લે છે.
class Person { virtual double discount(); };
class Student : public Person { double discount(); };
At a glance
Overloading સામે overriding, પરીક્ષાનું કોષ્ટક
| પાસું | Overloading | Overriding |
|---|---|---|
| Signature | જુદું હોવું જ જોઈએ (parameters) | બરાબર મળતું હોવું જોઈએ |
| ક્યાં | એ જ scope કે class | Base class સામે derived class |
| Inheritance જોઈએ | ના | હા |
| ક્યારે ઉકેલાય | Compile ના સમયે | Run ના સમયે (virtual સાથે) |
| Polymorphism નું કુટુંબ | Compile-time (static) | Run-time (dynamic) |
Quiz
એક જ class માં, student લખે છે: int calc(int a); અને double calc(int a); અને overload ની અપેક્ષા રાખે છે. શું થાય છે?
- Compile ની ભૂલ: ફક્ત જુદો return type function ને overload કરી શકતો નથી
- એ ચાલે છે: return types signatures ને જુદાં બનાવે છે
- એ ચાલે છે, પણ હંમેશા ફક્ત int વાળી આવૃત્તિ જ બોલાવાય છે
- calc પહેલી વાર બોલાવાય ત્યારે runtime ની ભૂલ
Show the answer
Compile ની ભૂલ: ફક્ત જુદો return type function ને overload કરી શકતો નથી
Overload ની પસંદગી ફક્ત parameter ની યાદી જુએ છે. બંને functions (int) લે છે, એટલે compiler માટે એ એક જ function છે જે ટકરાતા return types સાથે બે વાર declare થયું છે: ભૂલ. અસ્તિત્વમાં આ overloading ની સૌથી વધુ પુછાતી હકીકત છે. Overload કરવા parameters બદલો: calc(int) અને calc(double) બરાબર ચાલત.
Think first
આ ચારનું વર્ગીકરણ કરો
Tap કરતાં પહેલાં દરેકને overloading કે overriding તરીકે ઓળખાવો:
1. એક જ class માં Item() અને Item(char n[], double p)
2. Staff એ Person નું show() એ જ signature સાથે ફરી વ્યાખ્યાયિત કરવું
3. એક જ file માં print(int) અને print(char)
4. Student એ Person માંનું discount() ફરી વ્યાખ્યાયિત કરવું
Show the answer
1. Overloading (જુદી parameter ની યાદીવાળા constructors, overloading નો રોજિંદો ઉપયોગ).
2. Overriding (base સામે derived, એ જ signature).
3. Overloading (એ જ scope, જુદા parameter ના પ્રકાર).
4. Overriding (cards ના કુટુંબનો આખો મુદ્દો).
ફરી વાપરવા જેવી ઝડપી કસોટી: એક જ જગ્યાએ જુદા params = overloading; માતાપિતા અને સંતાનની જોડમાં એક જ signature = overriding.
Watch out
Marks ગુમાવનારા ત્રણ
1. Overloading ને inheritance જોઈએ એવો દાવો: નથી જોઈતું; એ એક જ scope ની અંદર વસે છે.
2. ફક્ત return type overload કરી શકે એવો દાવો: ન કરી શકે; parameters જુદા હોવા જ જોઈએ.
3. virtual ભૂલી જવું: એના વગરનું overriding compile તો થાય જ છે, પણ base class નું pointer base ની આવૃત્તિ બોલાવશે (early binding). Overriding ત્યારે જ run-time polymorphism બને છે જ્યારે base નું function virtual declare થયું હોય.
Theory
દરેક પોતાની કિંમત ક્યાં વસૂલ કરે છે
Overloading વાસ્તવમાં: constructors (default વત્તા parameterized વત્તા copy, એક નામ, ત્રણ સ્વરૂપ) અને operator overloading (total + item નો તમારા પોતાના પ્રકારો માટે અર્થ સર્જવો).
Overriding વાસ્તવમાં: તમે ક્યારેય વાપરશો એ દરેક framework તમને એક base class આપે છે અને એના hooks ને override કરવાની અપેક્ષા રાખે છે: Android નું onCreate(), game engine નું update(). Cards ના કુટુંબનું discount() એ જ ભાત નાના પાયે છે.
Summary
Key takeaways
- Overloading: એક જ નામ, જુદી parameter ની યાદી, એક જ scope, compile ના સમયની પસંદગી.
- Overriding: એક જ નામ, એક જ signature, base સામે derived, virtual હોય ત્યારે run ના સમયની પસંદગી.
- ફક્ત return type ક્યારેય function ને overload કરી શકતો નથી.
- Overloading ને inheritance જોઈતું નથી; overriding એના વગર અસ્તિત્વમાં જ ન આવે.
- ઉપયોગ: overload થયેલા constructors અને operators; discount() જેવા override થયેલા hooks.
- Memory hook: એક counter અનેક રીતો સામે franchise કુટુંબની વાનગી ફરી લખે છે.