Dynamic dispatch એ રનટાઇમ મેકેનિઝમ છે જે કયો મેથડ ઇમ્પ્લીમેન્ટેશન ચલાવવો તે વેરીએબલના ઘોષિત પ્રકારને બદલે ઑબ્જેક્ટના વાસ્તવિક પ્રકાર પર આધારે નક્કી કરે છે. મોટાભાગની ક્લાસ-આધારિત ભાષાઓ તેને વર્ચુઅલ મેથડ ટેબલ (vtable) સાથે અમલમાં મૂકે છે.
પ્રત્યેક વર્ગ પાસે તેના મેથડ ઇમ્પ્લીમેન્ટેશનમાં પોઇન્ટર્સનું એક ટેબલ છે. દરેક ઑબ્જેક્ટ તેના વર્ગના vtable તરફ એક છુપાયેલ પોઇન્ટર ધરાવે છે. વર્ચુઅલ કૉલ બને છે:
Animal a = new Dog();
a.speak();
a ──▶ Dog object ──▶ [Dog vtable]
speak() ──▶ Dog.speak() ← chosen at RUNTIME
કમ્પાઇલર Animal.speak હાર્ડ-કોડ કરતો નથી; તે "આ ઑબ્જેક્ટ જે vtable તરફ નિર્દેશ કરે તેના સ્લૉટ N ને કૉલ કરો" બહાર કાઢે છે.
Animal a = new Dog(); // declared Animal, actual Dog
a.speak(); // → Dog.speak(), because dispatch uses the OBJECT
| ભાષા | ડિફૉલ્ટ | નોટ્સ |
|---|---|---|
| Java | ડિફૉલ્ટ રીતે વર્ચુઅલ | final/static/private બિન-વર્ચુઅલ છે |
| C++ | ડિફૉલ્ટ રીતે બિન-વર્ચુઅલ | ડાયનામિક ડિસ્પેચ માટે virtual ચિહ્નિત કરવું આવશ્યક છે |
| Python | હંમેશા ગતિશીલ | ઑબ્જેક્ટના dict/MRO દ્વારા મેથડ લુકઅપ |
ત્યાં એક નાની કિંમત છે (એક પરોક્ષતા) અને તે ઇનલાઇનિંગને અવરોધે છે. C++ માં, virtual ભૂલી જવું એટલે કૉલ્સ સ્થિર રીતે બાંધાય છે અને ઓવરરાઇડ્સ ચુપચાપ કૉલ કરવામાં આવતા નથી — એક સૂક્ષ્મ બગ.
डિસ્પેચ સમજવું સમજાવે છે કે શા માટે ઓવરરાઇડીંગ કામ કરે છે અને શા માટે ઘોષિત પ્રકાર વર્તન નક્કી કરતો નથી — મૂંઝવણનો સામાન્ય સ્ત્રોત.
તે વાસ્તવિક પરિણામો પણ સ્પષ્ટ કરે છે: વર્ચુઅલ કૉલ્સની કામગીરીની કિંમત, કનસ્ટ્રક્ટર્સ શા માટે વર્ચુઅલ મેથડ્સને કૉલ કરવા જોઈએ નહીં, અને C++ શા માટે virtual સ્પષ્ટપણે આવશ્યક છે.